PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiIgDQogImh0dHA6Ly93d3cudzMub3JnL1RSL2h0bWw0L2xvb3NlLmR0ZCI+DQo8IS0tDQogICBMaWNlbnNlZCB0byB0aGUgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24gKEFTRikgdW5kZXIgb25lDQogICBvciBtb3JlIGNvbnRyaWJ1dG9yIGxpY2Vuc2UgYWdyZWVtZW50cy4gIFNlZSB0aGUgTk9USUNFIGZpbGUNCiAgIGRpc3RyaWJ1dGVkIHdpdGggdGhpcyB3b3JrIGZvciBhZGRpdGlvbmFsIGluZm9ybWF0aW9uDQogICByZWdhcmRpbmcgY29weXJpZ2h0IG93bmVyc2hpcC4gIFRoZSBBU0YgbGljZW5zZXMgdGhpcyBmaWxlDQogICB0byB5b3UgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlDQogICAiTGljZW5zZSIpOyB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlDQogICB3aXRoIHRoZSBMaWNlbnNlLiAgWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0DQoNCiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wDQoNCiAgIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywNCiAgIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuDQogICAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkNCiAgIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuICBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZQ0KICAgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZCBsaW1pdGF0aW9ucw0KICAgdW5kZXIgdGhlIExpY2Vuc2UuDQotLT4NCjxodG1sPg0KPGhlYWQ+DQogPCEtLSBzYXZlZCBmcm9tIHVybD0oMDAxNClhYm91dDppbnRlcm5ldCAtLT4NCiA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIi8+DQogPG1ldGEgbmFtZT0iQXV0aG9yIiBjb250ZW50PSJNYWxjb2xtIEVkZ2FyIi8+DQogPG1ldGEgbmFtZT0iZGVzY3JpcHRpb24iIGxhbmc9ImVuIiBjb250ZW50PSJBcGFjaGUgQ2xpY2sgSmF2YSB3ZWIgYXBwbGljYXRpb24gZnJhbWV3b3JrIi8+DQogPG1ldGEgbmFtZT0ia2V5d29yZHMiIGxhbmc9ImVuIiBjb250ZW50PSJBcGFjaGUgQ2xpY2ssIENsaWNrIEZyYW1ld29yaywgSmF2YSwgSkVFLCBKMkVFLCB3ZWIgYXBwbGljYXRpb24gZnJhbWV3b3JrLCBvcGVuIHNvdXJjZSIvPg0KIDx0aXRsZT5BcGFjaGUgQ2xpY2s8L3RpdGxlPg0KIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgdHlwZT0idGV4dC9jc3MiIGhyZWY9Ii4uL2hlbHAuY3NzIi8+DQogPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiB0eXBlPSJ0ZXh0L2NzcyIgaHJlZj0iLi4vc3ludGF4LWhpZ2hsaWdodGVyLmNzcyIvPg0KIDxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+DQogIGRsIHsNCiAgICBtYXJnaW4tbGVmdDogMmVtOw0KICB9DQogIGR0IHsNCiAgICBmb250LXdlaWdodDogNzAwOw0KICAgIG1hcmdpbi10b3A6IDEuNWVtOw0KICAgIG1hcmdpbi1ib3R0b206IDAuNWVtOw0KICB9DQogIC5jaGFuZ2Ugew0KICAgIG1hcmdpbi1ib3R0b206IDAuNzVlbTsNCiAgfQ0KICAudXBncmFkZSB7DQogICAgbWFyZ2luLWJvdHRvbTogMC43NWVtOw0KICAgIG1hcmdpbi10b3A6IDAuNzVlbTsNCiAgfQ0KICAucmVsZWFzZS1oZWFkZXIgew0KICAgIGJhY2tncm91bmQ6ICNFRkVGRjc7DQogICAgcGFkZGluZzogNHB4Ow0KICAgIHBhZGRpbmctbGVmdDogOHB4Ow0KICAgIGJvcmRlcjogMXB4IHNvbGlkICM5OUE0REY7DQogIH0NCiAgcHJlIHsNCiAgICBwYWRkaW5nOiA0cHg7DQogICAgYm9yZGVyOiAxcHggc29saWQgIzk5QTRERjsNCiAgfQ0KICBhIHsNCiAgCXRleHQtZGVjb3JhdGlvbjogbm9uZTsNCiAgfQ0KIDwvc3R5bGU+DQo8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSIuLi9zeW50YXgtaGlnaGxpZ2h0ZXIuanMiPjwvc2NyaXB0Pg0KPC9oZWFkPg0KPCEtLUFjdGl2YXRlIHN5bnRheCBoaWdobGlnaHRpbmctLT4NCiA8Ym9keSBvbmxvYWQ9InByZXR0eVByaW50KCk7Ij4NCg0KPGgxPlJvYWQgTWFwIGFuZCBDaGFuZ2VzPC9oMT4NCg0KPGgyPlJvYWQgTWFwPC9oMj4NCk5ldyBDbGljayByZWxlYXNlcyB3aWxsIGJlIHJlbGVhc2VkIGV2ZXJ5IHF1YXJ0ZXIgd2l0aCB0aGUgbmV4dCB2ZXJzaW9uIENsaWNrIDIuMi4wDQpzY2hlZHVsZWQgZm9yIHRoZSBlbmQgb2YgTWFyY2ggMjAxMC4gVGVudGF0aXZlIGZlYXR1cmVzIGZvciB0aGUgbmV4dCByZWxlYXNlDQppbmNsdWRlcyBpbXByb3ZlZCBBamF4IHN1cHBvcnQsIEBCaW5kYWJsZSBzdXBwb3J0IGZvciBQYWdlIGdldHRlcnMvc2V0dGVycyBhbmQNCmFuIGltcHJvdmVkIE1lbnUgY29udHJvbC4NCg0KPHA+Jm5ic3A7PC9wPg0KDQo8aDI+Q2hhbmdlczwvaDI+DQoNCjxkbD4NCiAgPGR0PjxhIG5hbWU9IjIuMS4wIj48L2E+DQogICAgPGRpdiBjbGFzcz0icmVsZWFzZS1oZWFkZXIiPkxhdGVzdCBTdGFibGUgUmVsZWFzZSAtIFZlcnNpb24gMi4xLjAgLSAxMCBGZWJydWFyeSAyMDEwPC9kaXY+DQogIDwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICBJTVBPUlRBTlQgYmUgc3VyZSB0byByZWFkIHRoZSA8YSBocmVmPSJ1cGdyYWRlLXBhdGguaHRtbCI+dXBncmFkZSBwYXRoPC9hPg0KICAgICAgd2hlbiB1cGdyYWRpbmcgZnJvbSBwcmV2aW91cyByZWxlYXNlcy4NCiAgICA8L2Rpdj4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICA8Yj5QbGVhc2UgTm90ZTo8L2I+DQogICAgICBUaGlzIHJlbGVhc2UgcmVxdWlyZXMgSmF2YSAxLjUgb3IgbGF0ZXIuDQogICAgPC9kaXY+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIDxiPk5ldyBleGFtcGxlczo8L2I+DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vd3d3LmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9nZW5lcmFsL3BhZ2UtaGVhZC1kZW1vLmh0bSI+DQogICAgICAgIFBhZ2UgSEVBRCBlbGVtZW50czwvYT4gZGVtb25zdHJhdGVzIGhvdyB0byBhZGQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Kc0ltcG9ydC5odG1sIj5Kc0ltcG9ydDwvYT4sDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvSnNTY3JpcHQuaHRtbCI+SnNTY3JpcHQ8L2E+LA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0Nzc0ltcG9ydC5odG1sIj5Dc3NJbXBvcnQ8L2E+DQogICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0Nzc1N0eWxlLmh0bWwiPkNzc1N0eWxlPC9hPg0KICAgICAgICBIRUFEIGVsZW1lbnRzIHRvIGEgUGFnZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly93d3cuYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2dlbmVyYWwvY29udHJvbC1oZWFkLWRlbW8uaHRtIj4NCiAgICAgICAgQ29udHJvbCBIRUFEIGVsZW1lbnRzPC9hPiBkZW1vbnN0cmF0ZXMgaG93IHRvIGFkZA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0pzSW1wb3J0Lmh0bWwiPkpzSW1wb3J0PC9hPiBhbmQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Dc3NJbXBvcnQuaHRtbCI+Q3NzSW1wb3J0PC9hPg0KICAgICAgICBIRUFEIGVsZW1lbnRzIHRvIGEgY3VzdG9tIENvbnRyb2wuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vd3d3LmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9jb250cm9sL3N1Ym1pdC1saW5rLWRlbW8uaHRtIj4NCiAgICAgICAgICBTdWJtaXRMaW5rIERlbW88L2E+IHNob3dzIGhvdyB0byB1c2UgdGhlIG5ldyA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvU3VibWl0TGluay5odG1sIj5TdWJtaXRMaW5rPC9hPiBjb250cm9sLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL3d3dy5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvdGFibGUvbGFyZ2UtZGF0YXNldC1kZW1vLmh0bSI+DQogICAgICAgIExhcmdlIERhdGFzZXQ8L2E+IGlzIGFuIGV4YW1wbGUgb2YgYSBUYWJsZSB3aXRoIGEgbGFyZ2UgbnVtYmVyIG9mIHJvd3MNCiAgICAgICAgYW5kIGhvdyB0byBsYXppbHkgcGFnZSB0aHJvdWdoIHRoZSByb3dzIHVzaW5nIGEgY3VzdG9tIGRhdGEgcHJvdmlkZXIuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vd3d3LmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9wYW5lbC9yZXVzYWJsZS1wYW5lbC1kZW1vLmh0bSI+DQogICAgICAgICAgUmV1c2FibGUgUGFuZWw8L2E+IGlzIGFuIGV4YW1wbGUgb2YgYSByZXVzYWJsZSBQYW5lbA0KICAgICAgICAgIHdoaWNoIHByb3ZpZGVzIGEgRm9ybSBmb3IgY2FwdHVyaW5nIENsaWVudCBkZXRhaWxzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL3d3dy5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvcXVhcnR6L3F1YXJ0ei1qb2Itc2NoZWR1bGVyLmh0bSI+DQogICAgICAgICAgUXVhcnR6IEpvYiBTY2hlZHVsZXI8L2E+IGlzIGFuIGV4YW1wbGUgZGVtb25zdHJhdGluZyBob3cgdG8gaW50ZWdyYXRlIHRoZSBRdWFydHogSm9iIFNjaGVkdWxpbmcgZnJhbWV3b3JrDQogICAgICAgICAgaW50byBhIENsaWNrIGFwcGxpY2F0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL3d3dy5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvZ2VuZXJhbC9leGNlbC10YWJsZS1leHBvcnQuaHRtIj4NCiAgICAgICAgICBFeGNlbCBUYWJsZSBFeHBvcnRlcjwvYT4gZXhhbXBsZSBkZW1vbnN0cmF0ZXMgaG93IHRvIGV4cG9ydCBhIENsaWNrIFRhYmxlDQogICAgICAgICAgdG8gYW4gRXhjZWwgc3ByZWFkc2hlZXQgdXNpbmcNCiAgICAgICAgICA8YSBjbGFzcz0iZXh0ZXJuYWwiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vcG9pLmFwYWNoZS5vcmcvIj5BcGFjaGUgUE9JPC9hPi4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0OiAtMmVtOyBtYXJnaW4tdG9wOiAxLjVlbTsgbWFyZ2luLWJvdHRvbTogMWVtOyI+DQogICAgICA8Yj5OZXcgZG9jdW1lbnRhdGlvbjo8L2I+DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpPg0KICAgICAgICBEb2N1bWVudGF0aW9uIGhhcyBiZWVuIGNvbnZlcnRlZCB0byBEb2Nib29rIGFuZCBhcmUgbWFkZSBhdmFpbGFibGUgaW4NCiAgICAgICAgdGhyZWUgZGlmZmVyZW50IGZsYXZvcnM6IDxhIGhyZWY9InVzZXItZ3VpZGUuaHRtbCI+UERGLCBIVE1MIChzaW5nbGUgcGFnZSkgYW5kIEhUTUwgKG11bHRpcGxlIHBhZ2VzKTwvYT4uDQogICAgICAgIFRoYW5rcyB0byBHaWxiZXJ0byBDIEFuZHJhZGUgZm9yIGRvaW5nIHRoZSBjb252ZXJzaW9uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDgyIj40ODI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIEFkZGVkIGRvY3VtZW50YXRpb24gZGVzY3JpYmluZyB0aGUgbmV3IEhFQUQgZWxlbWVudCBzdXBwb3J0Lg0KICAgICAgICBQbGVhc2Ugc2VlIHRoZSBuZXcgc2VjdGlvbiBvbiBQYWdlIEhFQUQgZWxlbWVudHMNCiAgICAgICAgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDJzMTIuaHRtbCI+aGVyZTwvYT4gYW5kDQogICAgICAgIHRoZSBzZWN0aW9uIG9uIENvbnRyb2wgSEVBRCBlbGVtZW50cyA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwM3MwNS5odG1sIj5oZXJlPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIEFkZGVkIGEgbmV3IHNlY3Rpb24sIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAzLmh0bWwjZGVwbG95aW5nLXJlc3RyaWN0ZWQtZW52Ij5EZXBsb3lpbmcgcmVzb3VyY2VzIGluIGEgcmVzdHJpY3RlZCBlbnZpcm9ubWVudDwvYT4sDQogICAgICAgIGRlc2NyaWJpbmcgaG93IHRvIGRlcGxveSBzdGF0aWMgcmVzb3VyY2VzIGluIGVudmlyb25tZW50cyB3aGVyZQ0KICAgICAgICBXQVIvRUFSIGFyZSBub3QgdW5wYWNrZWQgb3Igd2hlcmUgZmlsZSBzeXN0ZW0gcGVybWlzc2lvbnMgYXJlDQogICAgICAgIHJlc3RyaWN0ZWQsIHN1Y2ggYXMNCiAgICAgICAgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9hcHBlbmdpbmUvZG9jcy9qYXZhL292ZXJ2aWV3Lmh0bWwiPkdvb2dsZSBBcHAgRW5naW5lPC9hPi4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0OiAtMmVtOyBtYXJnaW4tdG9wOiAxLjVlbTsgbWFyZ2luLWJvdHRvbTogMWVtOyI+DQogICAgICA8Yj5EZXByZWNhdGVkOjwvYj4NCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtO21hcmdpbi1ib3R0b206IDJlbSI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgRGVwcmVjYXRlZCBtZXRob2RzOiA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwjZ2V0SHRtbEltcG9ydHMoKSI+Q29udHJvbC5nZXRIdG1sSW1wb3J0cygpPC9hPiBhbmQNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjZ2V0SHRtbEltcG9ydHMoKSI+UGFnZS5nZXRIdG1sSW1wb3J0cygpPC9hPi4NCiAgICAgICAgICBUaGVzZSBtZXRob2RzIGhhdmUgYmVlbiBkZXByZWNhdGVkIGluIGZhdm9yIG9mDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI2dldEhlYWRFbGVtZW50cygpIj5Db250cm9sLmdldEhlYWRFbGVtZW50cygpPC9hPg0KICAgICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjZ2V0SGVhZEVsZW1lbnRzKCkiPlBhZ2UuZ2V0SGVhZEVsZW1lbnRzKCk8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBEZXByZWNhdGVkIG1ldGhvZHM6IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNnZXRQYWdlSW1wb3J0cygpIj5QYWdlLmdldFBhZ2VJbXBvcnRzKCk8L2E+DQogICAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzZXRQYWdlSW1wb3J0cyhvcmcuYXBhY2hlLmNsaWNrLnV0aWwuUGFnZUltcG9ydHMpIj5QYWdlLnNldFBhZ2VJbXBvcnRzKCk8L2E+Lg0KICAgICAgICAgIFRoZXNlIG1ldGhvZHMgaGF2ZSBiZWVuIGRlcHJlY2F0ZWQgaW4gZmF2b3Igb2YNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjZ2V0SGVhZEVsZW1lbnRzKCkiPlBhZ2UuZ2V0SGVhZEVsZW1lbnRzKCk8L2E+Lg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KDQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIDxiPk5ldyBmZWF0dXJlcyBhbmQgaXNzdWVzIHJlc29sdmVkOjwvYj4NCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtO21hcmdpbi1ib3R0b206IDJlbSI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9hcHBlbmdpbmUvZG9jcy9qYXZhL292ZXJ2aWV3Lmh0bWwiPkdvb2dsZSBBcHAgRW5naW5lPC9hPiwNCiAgICAgICAgICBhIGZyZWUgSmF2YSBob3N0aW5nIGVudmlyb25tZW50IGZyb20gR29vZ2xlLiBUaGlzIHByb3ZpZGVzIGFuIGlkZWFsDQogICAgICAgICAgZW52aXJvbm1lbnQgZm9yIHN0dWRlbnRzIGFuZCBzdGFydHVwcyB0byBlYXNpbHkgaG9zdCB0aGVpciBDbGljaw0KICAgICAgICAgIGFwcGxpY2F0aW9ucyBvbmxpbmUuIFNlZSA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2dhZS9Hb29nbGVBcHBFbmdpbmVMaXN0ZW5lci5odG1sIj5Hb29nbGVBcHBFbmdpbmVMaXN0ZW5lcjwvYT4NCiAgICAgICAgICBmb3IgZGV0YWlscw0KICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTYwIj41NjA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgYW4gaW4tbWVtb3J5IDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvZ2FlL01lbW9yeUZpbGVVcGxvYWRTZXJ2aWNlLmh0bWwiPkZpbGUgVXBsb2FkIFNlcnZpY2U8L2E+DQogICAgICAgICAgdGhhdCBjYW4gYmUgdXNlZCBmb3IgdXBsb2FkaW5nIGZpbGVzIGluIGEgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9hcHBlbmdpbmUvZG9jcy9qYXZhL292ZXJ2aWV3Lmh0bWwiPkdvb2dsZSBBcHAgRW5naW5lPC9hPg0KICAgICAgICAgIGVudmlyb25tZW50Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciB0ZW1wbGF0ZXMgd2l0aCBjdXN0b20gZXh0ZW5zaW9ucyB0aHJvdWdoIHRoZSBuZXcNCiAgICAgICAgICBDb25maWdTZXJ2aWNlLjxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvQ29uZmlnU2VydmljZS5odG1sI2lzVGVtcGxhdGUoamF2YS5sYW5nLlN0cmluZykiPmlzVGVtcGxhdGU8L2E+DQogICAgICAgICAgbWV0aG9kLiBUaGUgZGVmYXVsdCBDb25maWdTZXJ2aWNlIGltcGxlbWVudGF0aW9uLCBYbWxDb25maWdTZXJ2aWNlLCBwcm92aWRlcw0KICAgICAgICAgIHN1cHBvcnQgZm9yIHRoZSBleHRlbnNpb25zIDx0dD4uaHRtPC90dD4gYW5kIDx0dD4uanNwPC90dD4sIGJ1dCBuZXcgZXh0ZW5zaW9ucw0KICAgICAgICAgIGNhbiBiZSBwcm92aWRlZCBpbiBhIHN1YmNsYXNzLiBTZWUgdGhlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvWG1sQ29uZmlnU2VydmljZS5odG1sI2lzVGVtcGxhdGUoamF2YS5sYW5nLlN0cmluZykiPkphdmFEb2M8L2E+DQogICAgICAgICAgZm9yIGRldGFpbHMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU2OCI+NTY4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIHN1cHBvcnQgdG8gdGhlIFBhZ2UgY2xhc3MgZm9yIGNvbmRpdGlvbmFsbHkgaW5jbHVkaW5nIENvbnRyb2wNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjZ2V0SGVhZEVsZW1lbnRzKCkiPmhlYWQgZWxlbWVudHM8L2E+DQogICAgICAgICAgdGhyb3VnaCB0aGUgbmV3IG1ldGhvZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0SW5jbHVkZUNvbnRyb2xIZWFkRWxlbWVudHMoYm9vbGVhbikiPmluY2x1ZGVDb250cm9sSGVhZEVsZW1lbnRzPC9hPg0KICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTcxIj41NzE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgc3VwcG9ydCB0byBkZXBsb3kgcmVzb3VyY2VzIGluc2lkZSBKQVJzIGZyb20gdGhlIFNlcnZsZXQgMy4wIGNvbXBsaWFudA0KICAgICAgICAgIGxvY2F0aW9uLCA8dHQ+TUVUQS1JTkYvcmVzb3VyY2VzPC90dD4uIENsaWNrJ3Mgb3duIHByZS1wYWNrYWdlZCByZXNvdXJjZXMNCiAgICAgICAgICBhcmUgbm93IGFsc28gbG9jYXRlZCBpbiB0aGUgSkFSIHVuZGVyIDx0dD5NRVRBLUlORi9yZXNvdXJjZXM8L3R0Pg0KICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTcwIj41NzA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgbmV3IENhbGVuZGFyIHBvcHVwIHRvIERhdGVGaWVsZC4gVGhpcyBDYWxlbmRhciBwb3B1cCB1c2VzDQogICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9wL2NhbGVuZGFyZGF0ZXNlbGVjdC8iPkNhbGVuZGFyIERhdGUgU2VsZWN0PC9hPg0KICAgICAgICAgIHdoaWNoIGlzIGJhc2VkIG9uIHRoZSBQcm90b3R5cGUgSmF2YVNjcmlwdCBsaWJyYXJ5Lg0KICAgICAgICAgIDxwLz4NCiAgICAgICAgICBQbGVhc2Ugbm90ZSBpZiB5b3UgZG9uJ3Qgd2FudCBhIGRlcGVuZGVuY3kgb24gdGhlIFByb3RvdHlwZSBsaWJyYXJ5DQogICAgICAgICAgeW91IGNhbiB1c2UgdGhlIHRoaXJkLXBhcnR5DQogICAgICAgICAgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9wL2NsaWNrLWNhbGVuZGFyLyI+Q2xpY2sgQ2FsZW5kYXI8L2E+DQogICAgICAgICAgaW5zdGVhZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgZmlyc3QgY2xhc3Mgc3VwcG9ydCBmb3IgSEVBRCBlbGVtZW50cyBzdWNoIGFzIEphdmFTY3JpcHQgYW5kIENzcy4NCiAgICAgICAgICBUaGUgZm9sbG93aW5nIGNsYXNzZXMgd2VyZSBhZGRlZDoNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0VsZW1lbnQuaHRtbCI+RWxlbWVudDwvYT4sDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9SZXNvdXJjZUVsZW1lbnQuaHRtbCI+UmVzb3VyY2VFbGVtZW50PC9hPiwNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0pzSW1wb3J0Lmh0bWwiPkpzSW1wb3J0PC9hPiwNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0pzU2NyaXB0Lmh0bWwiPkpzU2NyaXB0PC9hPiwNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0Nzc0ltcG9ydC5odG1sIj5Dc3NJbXBvcnQ8L2E+DQogICAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvQ3NzU3R5bGUuaHRtbCI+Q3NzU3R5bGU8L2E+Lg0KICAgICAgICAgIEEgbmV3IG1ldGhvZCB3YXMgYWRkZWQgdG8gUGFnZSBhbmQgQ29udHJvbDogPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI2dldEhlYWRFbGVtZW50cygpIj5Db250cm9sLmdldEhlYWRFbGVtZW50cygpPC9hPg0KICAgICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjZ2V0SGVhZEVsZW1lbnRzKCkiPlBhZ2UuZ2V0SGVhZEVsZW1lbnRzKCk8L2E+DQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01MDEiPjUwMTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvU3VibWl0TGluay5odG1sIj5TdWJtaXRMaW5rPC9hPiBjb250cm9sDQogICAgICAgICAgdGhhdCBjYW4gc3VibWl0IGEgRm9ybSBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUxOSI+NTE5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICAgIEFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9IaWRkZW5MaXN0Lmh0bWwiPkhpZGRlbkxpc3Q8L2E+IGNvbnRyb2wNCiAgICAgICAgICBmb3IgcmVuZGVyaW5nIGFuZCBzdWJtaXR0aW5nIGEgbGlzdCBvZiBoaWRkZW4gZmllbGRzIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDkxIj40OTE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgcGx1Zy1hYmxlIHNlY3VyaXR5IGFjY2VzcyBjb250cm9sbGVyICg8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NlY3VyaXR5L0FjY2Vzc0NvbnRyb2xsZXIuaHRtbCI+QWNjZXNzQ29udHJvbGxlcjwvYT4pIHRvIE1lbnUgY2xhc3MuDQogICAgICAgICAgVGhpcyBwbHViYWJsZSBpbnRlcmZhY2UgZW5hYmxlIHVzZSBvZiBzZWN1cml0eSBmcmFtZXdvcmtzIHN1Y2ggYXMgU3ByaW5nIFNlY3VyaXR5IChBY2VnaSkgb3IgSlNlY3VyaXR5IHRvIGNvbnRyb2wgdXNlciBhY2Nlc3MgdG8gTWVudSBpdGVtcy4NCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGVtZXRyaW9zIEt5cmlha2lzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2NsaWNrL2Jyb3dzZS9DTEstNDA2Ij40MDY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgYW4gQW50IHRhc2ssIGNhbGxlZCBEZXBsb3lUYXNrLCBmb3IgZGVwbG95aW5nIHN0YXRpYyByZXNvdXJjZXMNCiAgICAgICAgICBhdCBidWlsZCB0aW1lLiBUaGlzIHRhc2sgaXMgdXNlZnVsIHdoZW4gZGVwbG95aW5nIENsaWNrIGFwcGxpY2F0aW9ucw0KICAgICAgICAgIGluIHJlc3RyaWN0ZWQgZW52aXJvbm1lbnRzLiBGb3IgbW9yZSBkZXRhaWxzIHNlZSB0aGUgc2VjdGlvbjoNCiAgICAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMy5odG1sI2RlcGxveWluZy1yZXN0cmljdGVkLWVudiI+ZGVwbG95aW5nIHJlc291cmNlcyBpbiBhIHJlc3RyaWN0ZWQgZW52aXJvbm1lbnQ8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBhIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvUmVzb3VyY2VTZXJ2aWNlLmh0bWwiPlJlc291cmNlU2VydmljZTwvYT4sDQogICAgICAgICAgZm9yIHNlcnZpbmcgc3RhdGljIHJlc291cmNlcyBhdCBydW50aW1lLiBUaGlzIHNlcnZpY2UgaXMgdXNlZnVsIHdoZW4NCiAgICAgICAgICBkZXBsb3lpbmcgQ2xpY2sgYXBwbGljYXRpb25zIGluIHJlc3RyaWN0ZWQgZW52aXJvbm1lbnRzLiBGb3IgbW9yZSBkZXRhaWxzDQogICAgICAgICAgc2VlIHRoZSBzZWN0aW9uOg0KICAgICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAzLmh0bWwjZGVwbG95aW5nLXJlc3RyaWN0ZWQtZW52Ij5kZXBsb3lpbmcgcmVzb3VyY2VzIGluIGEgcmVzdHJpY3RlZCBlbnZpcm9ubWVudDwvYT4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvY2xpY2svYnJvd3NlL0NMSy01NjQiPjU2NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBtZXRob2QsDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwjY3JlYXRlVGVtcGxhdGVNb2RlbChvcmcuYXBhY2hlLmNsaWNrLlBhZ2UsIG9yZy5hcGFjaGUuY2xpY2suQ29udGV4dCkiPkNsaWNrVXRpbHMuY3JlYXRlVGVtcGxhdGVNb2RlbDwvYT4sDQogICAgICAgICAgd2hpY2ggcmV0dXJucyBhIHRlbXBsYXRlIG1vZGVsIGNvbnRhaW5pbmcgb2JqZWN0cyBzdWNoIGFzIHRoZSBDb250ZXh0DQogICAgICAgICAgcGF0aCwgUGFnZSBwYXRoLCBIVFRQIHJlcXVlc3QsIEhUVFAgcmVzcG9uc2UsIEhUVFAgc2Vzc2lvbiBldGMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIGFiaWxpdHkgdG8gc3BlY2lmeSBhIGN1c3RvbSBUcmVlTm9kZSBpY29uIHRocm91Z2ggdGhlIG5ldyBtZXRob2QNCiAgICAgICAgICBUcmVlTm9kZS48YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZU5vZGUuaHRtbCNzZXRJY29uKGphdmEubGFuZy5TdHJpbmcpIj5zZXRJY29uKFN0cmluZyk8L2E+Lg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgVGltIEhvb3Blcg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDk0Ij40OTQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgbWV0aG9kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvRm9ybWF0Lmh0bWwjdXJsKGphdmEubGFuZy5PYmplY3QpIj5Gb3JtYXQudXJsPC9hPg0KICAgICAgICAgIGZvciBlbmNvZGluZyBVUkwncyBpbiB0ZW1wbGF0ZXMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM5OSI+Mzk5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIG1ldGhvZA0KICAgICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9GaWVsZENvbHVtbi5odG1sI3NldFByb3BlcnR5KGphdmEubGFuZy5PYmplY3QsIGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5PYmplY3QpIj5GaWVsZENvbHVtbi5zZXRQcm9wZXJ0eTwvYT4NCiAgICAgICAgICB0aGF0IGNhbiBiZSBvdmVycmlkZW4gdG8gcHJvdmlkZSBjdXN0b20gYmluZGluZyBmb3IgY29tcGxleA0KICAgICAgICAgIGRvbWFpbiBvYmplY3RzLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFdhcm5lckphbiBWZWxkaHVpcw0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTI4Ij41Mjg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgVHlwZUNvbnZlcnRlciBjb25maWd1cmF0aW9uIG9wdGlvbiB0byBDbGlja1NlcnZsZXQuIA0KICAgICAgICAgIFNlZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNnZXRUeXBlQ29udmVydGVyKCkiPmdldFR5cGVDb252ZXJ0ZXIoKTwvYT4NCiAgICAgICAgICBtZXRob2QgZm9yIGRldGFpbHMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBKb3NlcGggU2NobWlkdCBhbmQgZml4ZWQgYnkgQWRyaWFuIEEuDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01MzkiPjUzOTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NlcnZpY2UvU2xmNGpMb2dTZXJ2aWNlLmh0bWwiPlNsZjRqTG9nU2VydmljZTwvYT4NCiAgICAgICAgICBmb3Igc3VwcG9ydGluZyBtdWx0aXBsZSBhcHBsaWNhdGlvbiBzZXJ2ZXJzLiANCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgT2xpdmVyIEJ1cm4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU1NSI+NTU1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQmluZGFibGUuaHRtbCI+QEJpbmRhYmxlPC9hPiANCiAgICAgICAgICBhbm5vdGF0aW9uIHN1cHBvcnQgZm9yIHBhZ2UgZmllbGQgYXV0b2JpbmRpbmcuIEBCaW5kYWJsZSBzdXBwb3J0cyBwdWJsaWMsDQogICAgICAgICAgcHJvdGVjdGVkIGFuZCBwcml2YXRlIFBhZ2UgdmFyaWFibGVzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NTYiPjU1NjwvYT4sIA0KICAgICAgICAgICA8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTk5Ij41OTk8L2E+IA0KICAgICAgICAgIF0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBwcm9wZXJ0eSBmaWxlcyB3aXRoIHRyYW5zbGF0aW9uIGZvciB0aGUgUnVzc2lhbiBsYW5ndWFnZS4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBBbmRyZXkgUnliaW4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MDciPjYwNzwvYT5dLA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYxMSI+NjExPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IFRyZWUgbWV0aG9kcw0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZS5odG1sI3NldFdpZHRoKGphdmEubGFuZy5TdHJpbmcpIj5zZXRXaWR0aDwvYT4gLw0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZS5odG1sI2dldFdpZHRoKCkiPmdldFdpZHRoPC9hPg0KICAgICAgICBhbmQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL1RyZWUuaHRtbCNzZXRIZWlnaHQoamF2YS5sYW5nLlN0cmluZykiPnNldEhlaWdodDwvYT4gLw0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZS5odG1sI2dldEhlaWdodCgpIj5nZXRIZWlnaHQ8L2E+Lg0KICAgICAgICBBbHNvIGZpeGVkIHJlbmRlcmluZyBpc3N1ZXMgaW4gSUU2LzcgZm9yIGxvbmcgbm9kZSBsYWJlbHMgdGhhdCBvdmVyZmxvdw0KICAgICAgICB0aGUgdHJlZSB3aWR0aCBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYxNiI+NjE2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIFRoZSBjbGljay5kdGQgaGFzIGJlZW4gcHVibGlzaGVkIHRvDQogICAgICAgICAgPGEgaHJlZj0iaHR0cDovL2NsaWNrLmFwYWNoZS5vcmcvZHRkcy9jbGljay0yLjEuZHRkIj5odHRwOi8vY2xpY2suYXBhY2hlLm9yZy9kdGRzL2NsaWNrLTIuMS5kdGQ8L2E+Lg0KICAgICAgICAgIElmIHlvdSB3YW50IHlvdXIgY29uZmlndXJhdGlvbiB0byBjb25mb3JtIHRvIHRoZSBjbGljay5kdGQsIGluY2x1ZGUNCiAgICAgICAgICB0aGUgZm9sbG93aW5nIGRlY2xhcmF0aW9uIGluIHlvdXIgY2xpY2sueG1sOg0KICAgICAgICAgIDxwcmUgY2xhc3M9InByZXR0eXByaW50Ij4mbHQ7IURPQ1RZUEUgY2xpY2stYXBwIFBVQkxJQw0KICAgICAgICItLy9BcGFjaGUgU29mdHdhcmUgRm91bmRhdGlvbi8vRFREIENsaWNrIENvbmZpZ3VyYXRpb24gMi4xLy9FTiINCiAgICAgICAiaHR0cDovL2NsaWNrLmFwYWNoZS5vcmcvZHRkcy9jbGlja18yXzEuZHRkIiZndDsgPC9wcmU+DQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIEZvcm0gdmFsaWRhdGlvbiB0byBhbGxvdyBGb3JtIHN1YmNsYXNzZXMgdG8gb3ZlcnJpZGUgdGhlDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjdmFsaWRhdGUoKSI+dmFsaWRhdGU8L2E+DQogICAgICAgICAgbWV0aG9kIGFuZCBpbXBsZW1lbnQgY3Jvc3MtZmllbGQgdmFsaWRhdGlvbi4gVGhlIGZvbGxvd2luZw0KICAgICAgICAgIGNoYW5nZXMgd2VyZSBtYWRlOiB0aGUgcHJldmlvdXMgPHR0PnZhbGlkYXRlPC90dD4gbWV0aG9kIHdhcyByZW5hbWVkDQogICAgICAgICAgdG8gPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjdmFsaWRhdGVGaWxlVXBsb2FkKCkiPnZhbGlkYXRlRmlsZVVwbG9hZDwvYT4NCiAgICAgICAgICBhbmQgYSBuZXcgZW1wdHkgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjdmFsaWRhdGUoKSI+dmFsaWRhdGU8L2E+DQogICAgICAgICAgbWV0aG9kIHdhcyBpbnRyb2R1Y2VkLCB0aGF0IGNhbiBzYWZlbHkgYmUgb3ZlcnJpZGRlbiBpbiBzdWJjbGFzc2VzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NzIiPjU3MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBQYWdlIHJlZGlyZWN0IHRvIHN1cHBvcnQgcGFyYW1ldGVycy4gU2VlIHRoZSBuZXcgUGFnZSBtZXRob2RzDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3NldFJlZGlyZWN0KGphdmEubGFuZy5TdHJpbmcsIGphdmEudXRpbC5NYXApIj5zZXRSZWRpcmVjdChTdHJpbmcsIE1hcCk8L2E+DQogICAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzZXRSZWRpcmVjdChqYXZhLmxhbmcuQ2xhc3MsIGphdmEudXRpbC5NYXApIj5zZXRSZWRpcmVjdChDbGFzcywgTWFwKTwvYT4NCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEFkcmlhbg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTM2Ij41MzY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgTGluayBDb250cm9scyB0byBzdXBwb3J0IG11bHRpdmFsdWVkIHBhcmFtZXRlcnMgdGhyb3VnaCB0aGUNCiAgICAgICAgICBuZXcgQWJzdHJhY3RMaW5rIG1ldGhvZHMgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BYnN0cmFjdExpbmsuaHRtbCNnZXRQYXJhbWV0ZXJWYWx1ZXMoamF2YS5sYW5nLlN0cmluZykiPmdldFBhcmFtZXRlclZhbHVlcygpPC9hPg0KICAgICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0TGluay5odG1sI3NldFBhcmFtZXRlclZhbHVlcyhqYXZhLmxhbmcuU3RyaW5nLCBqYXZhLmxhbmcuU3RyaW5nW10pIj5zZXRQYXJhbWV0ZXJWYWx1ZXMoKTwvYT4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU1NCI+NTU0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIFRhYmxlIHRvIHN1cHBvcnQgdmVyeSBsYXJnZSBkYXRhc2V0cyBieSBwcm9tb3RpbmcgdGhlIG1ldGhvZHMNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1RhYmxlLmh0bWwjZ2V0Rmlyc3RSb3coKSI+Z2V0Rmlyc3RSb3coKTwvYT4NCiAgICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9UYWJsZS5odG1sI2dldExhc3RSb3coKSI+Z2V0TGFzdFJvdygpPC9hPg0KICAgICAgICAgIGFzIHB1YmxpYy4gVGhlc2UgbWV0aG9kcyBwcm92aWRlIHRoZSBuZWNlc3NhcnkgaW5mb3JtYXRpb24gdG8gb25seQ0KICAgICAgICAgIHJldHJpZXZlIHRoZSBkaXNwbGF5ZWQgcm93cw0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTA0Ij41MDQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgTGlua0RlY29yYXRvciB0byBzdXBwb3J0IHRhcmdldCBpZGVudGZpZXIgcHJvcGVydHkgcGFyYW1ldGVyIG5hbWVzLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEZW1ldHJpb3MgS3lyaWFraXMgYW5kIGZpeGVkIGJ5IGZpeGVkIGJ5IEFkcmlhbiBBLg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDAwIj40MDA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgUGlja0xpc3QgbWV0aG9kcyA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUGlja0xpc3QuaHRtbCNnZXRWYWx1ZU9iamVjdCgpIj5nZXRWYWx1ZU9iamVjdCgpPC9hPg0KICAgICAgICAgIGFuZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUGlja0xpc3QuaHRtbCNzZXRWYWx1ZU9iamVjdChqYXZhLmxhbmcuT2JqZWN0KSI+c2V0VmFsdWVPYmplY3QoT2JqZWN0KTwvYT4NCiAgICAgICAgICB0byBkZWxlZ2F0ZSB0byA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUGlja0xpc3QuaHRtbCNnZXRTZWxlY3RlZFZhbHVlcygpIj5nZXRTZWxlY3RlZFZhbHVlcygpPC9hPg0KICAgICAgICAgIGFuZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUGlja0xpc3QuaHRtbCNhZGRTZWxlY3RlZFZhbHVlKGphdmEubGFuZy5TdHJpbmcpIj5hZGRTZWxlY3RlZFZhbHVlKFN0cmluZyk8L2E+DQogICAgICAgICAgcmVzcGVjdGl2ZWx5IFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDkwIj40OTA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgU3ByaW5nIGludGVncmF0aW9uIHdpdGgNCiAgICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NwcmluZy9TcHJpbmdDbGlja1NlcnZsZXQuaHRtbCI+U3ByaW5nQ2xpY2tTZXJ2bGV0PC9hPiBhbmQNCiAgICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NwcmluZy9QYWdlU2NvcGVSZXNvbHZlci5odG1sIj5QYWdlU2NvcGVSZXNvbHZlcjwvYT4sDQogICAgICAgICAgc3VwcG9ydGluZyBTcHJpbmcgaW5zdGFudGlhdGVkIFBhZ2VzIHdpdGggQENvbXBvbmVudCBjb25maWd1cmF0aW9uDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01MzQiPjUzNDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBDb21wcmVzc2lvblNlcnZsZXRSZXNwb25zZVdyYXBwZXIgYW5kIENvbXByZXNzaW9uUmVzcG9uc2VTdHJlYW0gY2xhc3NlcyB0byBoYXZlDQogICAgICAgICAgcHVibGljIHZpc2liaWxpdHkgdG8gZW5hYmxlIHVzZSBpbiBjdXN0b20gc2VydmxldCBGaWx0ZXJzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2NsaWNrL2Jyb3dzZS9DTEstNTQ3Ij41NDc8L2E+XS4NCiAgICAgIDwvbGk+ICAgICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgTWVudSBjb250cm9sIHRvIHJlbmRlciBhdHRyaWJ1dGUgY2xhc3M9InNlbGVjdGVkIiB3aGVuIHRoZSBtZW51IGl0ZW0NCiAgICAgICAgICBpcyBzZWxlY3RlZC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBGcmVkZXJpYyBEYW91ZA0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9jbGljay9icm93c2UvQ0xLLTU1MSI+NTUxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIFBlcmZvcm1hbmNlRmlsdGVyIHRvIGltcGxlbWVudCBleGNsdWRlLXBhdGhzIGZpbHRlcmluZw0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9jbGljay9icm93c2UvQ0xLLTQ5OCI+NDk4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIFhtbENvbmZpZ1NlcnZpY2UgdG8gc2NhbiBmb3IgZGVwbG95YWJsZSByZXNvdXJjZXMgaW5zaWRlIGZvbGRlcnMNCiAgICAgICAgICBvbiB0aGUgY2xhc3NwYXRoDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2NsaWNrL2Jyb3dzZS9DTEstNTUyIj41NTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgQ2F5ZW5uZSBEYXRhQ29udGV4dEZpbHRlciwgaW5jbHVkaW5nIGFkZGluZyBzdXBwb3J0IGZvciBMaWZlY3ljbGVMaXN0ZW5lciANCiAgICAgICAgICByZWdpc3RyYXRpb24NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU1OSI+NTU5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWJzdHJhY3RMaW5rLmh0bWwiPkFic3RyYWN0TGluazwvYT4NCiAgICAgICAgICB0byBhbGxvdyByZW5kZXJpbmcgb2YgYm90aCBpY29uIGFuZCBsYWJlbCBpbiBMaW5rIGNvbnRyb2xzIChkZWZhdWx0DQogICAgICAgICAgYmVoYXZpb3IgcmVuZGVycyBlaXRoZXIgYSBsYWJlbCBvciBhbiBpY29uKQ0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTM1Ij41MzU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgUGFnZSBhbmQgQ29udHJvbCBtZXNzYWdlIGhhbmRsaW5nIHdpdGggbnVsbCBhcmdzLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBXYXJuZXJKYW4gVmVsZGh1aXMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYwMCI+NjAwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIHJlc291cmNlIGRlcGxveW1lbnQgb24gSkJvc3MgNSBhbmQgdXAuIFRoZSBzb2x1dGlvbiBpcyBiYXNlZCBvbg0KICAgICAgICAgIHRoZSB3b3JrIGRvbmUgYnkgdGhlIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuc3RyaXBlc2ZyYW1ld29yay5vcmciPlN0cmlwZXMgRnJhbWV3b3JrPC9hPg0KICAgICAgICAgIGRldmVsb3BlcnMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU4OSI+NTg5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vcC9jbGljay1jYWxlbmRhci8iPkNsaWNrIENhbGVuZGFyPC9hPg0KICAgICAgICAgIG1lbW9yeSBsZWFrIGluIGNhbGVuZGFyIHBvcHVwIHdpdGggdmVyc2lvbiAxLjAuMSByZWxlYXNlZA0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDk5Ij40OTk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgRml4ZWQgQ29sdW1uIHNvcnRpbmcgdG8gcmVjb2duaXplIG51bWJlcnMgaW5zaWRlIHN0cmluZ3MuDQogICAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFZlbmthdHQgR3VoZXNhbg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9jbGljay9icm93c2UvQ0xLLTQ4OSI+NDg5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIGEgYnVnIHdoZXJlIEZpZWxkU2V0IHdhcyBub3Qgc2V0IGFzIHRoZSBwYXJlbnQgb2YgaXRzIGNoaWxkIGNvbnRyb2xzLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBKYW1lcyBQIEJyb3duDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2NsaWNrL2Jyb3dzZS9DTEstNDk3Ij40OTc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJICBGaXhlZCBGb3JtVGFibGUgc29ydGluZyBidWcuIEFkZGVkIEZvcm1UYWJsZSBzb3J0IG1ldGhvZHMgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0Zvcm1UYWJsZS5odG1sI3NldFNvcnRlZENvbHVtbihqYXZhLmxhbmcuU3RyaW5nKSI+c2V0U29ydGVkQ29sdW1uPC9hPiwNCiAgICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvRm9ybVRhYmxlLmh0bWwjc2V0U29ydGVkQXNjZW5kaW5nKGJvb2xlYW4pIj5zZXRTb3J0ZWRBc2NlbmRpbmc8L2E+LA0KICAgICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9Gb3JtVGFibGUuaHRtbCNzZXRQYWdlTnVtYmVyKGludCkiPnNldFBhZ2VOdW1iZXI8L2E+DQogICAgICAgICAgZm9yIHByb2dyYW1tYXRpYyBzb3J0aW5nLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEJlbiBXYXJuZXINCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUyNyI+NTI3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIGEgYnVnIGluIEF1dG9Db21wbGV0ZVRleHRGaWVsZCB3aGVyZSBpZiB0aGUgZmllbGQgd2FzIHJlbW92ZWQNCiAgICAgICAgICBmcm9tIGEgRm9ybSwgaXRzIEphdmFTY3JpcHQgcmVzb3VyY2VzIHdvdWxkIHN0aWxsIGJlIHJlbmRlcmVkLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBQYXVsIFphbW1pdA0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTQ2Ij41NDY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgRml4ZWQgZXh0cmFzIDx0dD5wb20ueG1sPC90dD4gZGVwZW5kZW5jaWVzIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9jbGljay9icm93c2UvQ0xLLTQ5MiI+NDkyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIGEgYnVnIGluIGNvbnRyb2wuanMgd2hpY2ggY2F1c2VkIHRoZSBhZGRMb2FkRXZlbnQgZXZlbnQgcXVldWUgdG8NCiAgICAgICAgICBiZSByZXNldCBpZiBtdWx0aXBsZSBjb250cm9sLmpzIHNjcmlwdHMgYXJlIGltcG9ydGVkIGluIHRoZSBzYW1lIHBhZ2UuDQogICAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFkcmlhbg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTAzIj41MDM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgRml4ZWQgUGVyZm9ybWFuY2VGaWx0ZXIgYW5kIENvbXByZXNzaW9uRmlsdGVyIHRvIHByb3Blcmx5IGhhbmRsZQ0KICAgICAgICAgIDx0dD4mbHQ7anNwOmluY2x1ZGUmZ3Q7PC90dD4gcmVxdWVzdHMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU1NyI+NTU3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIFN1Ym1pdExpbmsgdG8gY2FsbCBGb3JtIGphdmFzY3JpcHQgdmFsaWRhdGlvbiBiZWZvcmUgc3VibWl0dGluZyBmb3JtLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgRmlubiBCb2NrDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01ODYiPjU4NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBGaXhlZCBEYXRlRmllbGQgbm90IHRvIHJlbmRlciBoZWxwIHByb3BlcnR5IHR3aWNlLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBGaW5uIEJvY2sNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU3NCI+NTc0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIGJ1ZyB3aGVyZSBwYWdlcyBpbiB0aGUgZGVmYXVsdCBwYWNrYWdlIHdhcyBub3QgbG9hZGVkLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBUaGlhZ28gU2VubmENCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU3NSI+NTc1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIGJ1ZyBpbiBIaWJlcm5hdGVGb3JtIHRoYXQgZGlkIG5vdCBhcHBseSByZXF1aXJlZCBmaWVsZCBjb25zdHJhaW50cw0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTgzIj41ODM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgVXBkYXRlZCBWZWxvY2l0eSBsaWJyYXJ5IHRvIHZlcnNpb24gMS42LjMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIFVwZGF0ZWQgQ2F5ZW5uZSBsaWJyYXJ5IHRvIHZlcnNpb24gMy4wTTYuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIFVwZGF0ZWQgQ29tbW9ucyBDb2xsZWN0aW9uIGxpYnJhcnkgdG8gdmVyc2lvbiAzLjIuMS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgVXBkYXRlZCBQcm90b3R5cGUuanMgbGlicmFyeSB0byB2ZXJzaW9uIDEuNi4xLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KDQogIDxkdD48ZGl2IGNsYXNzPSJyZWxlYXNlLWhlYWRlciI+QXJjaGl2ZXM8L2Rpdj48L2R0Pg0KDQogIDxkdD48YSBuYW1lPSIyLjEuMC1SQzEiPjwvYT5WZXJzaW9uIDIuMS4wLVJDMSAoQXBhY2hlIGluY3ViYXRvcikgLSAyOCBKdW5lIDIwMDk8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgU2VlIHRoZSByZWxlYXNlIG5vdGVzIGZvciA8YSBocmVmPSIjMi4xLjAtUkMyIj4yLjEuMDwvYT4uDQogICAgPC9kaXY+DQogIDwvZGQ+DQoNCiAgPGR0PjxhIG5hbWU9IjIuMC4xIj48L2E+VmVyc2lvbiAyLjAuMSAoQXBhY2hlIGluY3ViYXRvcikgLSAxNSBGZWJydWFyeSAyMDA5PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6IDE1cHg7IG1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIFRoaXMgaXMgb3VyIGZpcnN0IEFwYWNoZSBJbmN1YmF0b3IgcmVsZWFzZSBhbmQgaXMgYmFzZWQgb24gPGEgaHJlZj0iIzEuNS4xIj5DbGljayAxLjUuMTwvYT4uDQogICAgICA8cC8+DQogICAgICBQbGVhc2Ugbm90ZSB0aGF0IGJlY2F1c2Ugb2YgbGljZW5zaW5nIGlzc3VlcywgY2VydGFpbiB0aGlyZC1wYXJ0eQ0KICAgICAgbGlicmFyaWVzIHdlcmUgcmVtb3ZlZCBhbmQgYXJlIGhvc3RlZCBleHRlcm5hbGx5Lg0KICAgIDwvZGl2Pg0KICA8L2RkPg0KDQogIDxkdD48YSBuYW1lPSIxLjUuMSI+PC9hPlZlcnNpb24gMS41LjEgKHByZS1BcGFjaGUpIC0gMjMgSmFudWFyeSAyMDA5PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIFBsZWFzZSBub3RlIHRoYXQgdGhpcyByZWxlYXNlIGlzIHByb3ZpZGVkIG91dHNpZGUgb2YgdGhlIEFTRiBhbmQgaXMgbm90DQogICAgICBlbmRvcnNlZCBvciBhcHByb3ZlZCBieSB0aGUgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24uDQogICAgPC9kaXY+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDogMTVweDsgbWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPiANCiAgICAgIFRoZSBmb2xsb3dpbmcgaXNzdWVzIHdlcmUgcmVzb2x2ZWQgc2luY2UgMS41Og0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgVHVya2lzaCBsYW5ndWFnZSBzdXBwb3J0LiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEFsaSBPay4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NzYiPjQ3NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgZXhjZXB0aW9uIGhhbmRsaW5nIHdoZW4gYSBDb250cm9sIG5hbWUgaXMgbm90IGRlZmluZWQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NzMiPjQ3MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IGNvbnN0cnVjdG9ycyB0byBleHRyYSBjb250cm9scyB3aGljaCBhY2NlcHRzIHRoZSA8dHQ+c2l6ZTwvdHQ+DQogICAgICAgIGF0dHJpYnV0ZS4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IENocmlzdG9waGUgRm9pcmV0DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDc1Ij40NzU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIE1lc3NhZ2VGb3JtYXQgc3VwcG9ydCB0byBGb3JtYXQuIE5ldyBtZXRob2RzIGluY2x1ZGUNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Gb3JtYXQuaHRtbCNtZXNzYWdlKGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5PYmplY3QpIj5tZXNzYWdlKFN0cmluZywgT2JqZWN0KTwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvRm9ybWF0Lmh0bWwjbWVzc2FnZShqYXZhLmxhbmcuU3RyaW5nLCBqYXZhLnV0aWwuTGlzdCkiPm1lc3NhZ2UoU3RyaW5nLCBMaXN0KTwvYT4uDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBZdSBLb2JheWFzaGkNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NzQiPjQ3NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IG1ldGhvZHMgdG8gQ2hlY2tib3hUcmVlIHRvIGltcHJvdmUgY3VzdG9taXphdGlvbi4gVGhlIG5ldyBtZXRob2RzDQogICAgICAgIGluY2x1ZGUgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL0NoZWNrYm94VHJlZS5odG1sI3JlbmRlckNoZWNrYm94KG9yZy5hcGFjaGUuY2xpY2sudXRpbC5IdG1sU3RyaW5nQnVmZmVyLCBvcmcuYXBhY2hlLmNsaWNrLmV4dHJhcy50cmVlLlRyZWVOb2RlKSI+cmVuZGVyQ2hlY2tib3g8L2E+DQogICAgICAgIGFuZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvQ2hlY2tib3hUcmVlLmh0bWwjZ2V0SW5wdXRUeXBlKCkiPmdldElucHV0VHlwZTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBjc3YgbWltZSB0eXBlLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQWx2aW4gVG93bnNlbmQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBVUkwgcmVuZGVyaW5nIHRvIGVuY29kZSBhbXBlcnNhbmQgY2hhcmFjZXRlcnMuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDgzIj40ODM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEhpZGRlbkZpZWxkIHRvIHdvcmsgd2l0aCBqYXZhLnNxbC5UaW1lc3RhbXAsIGphdmEuc3FsLlRpbWUgYW5kIGphdmEuc3FsLkRhdGUuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDg0Ij40ODQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFdlYmFwcExvYWRlciB0byByZWxvYWQgVmVsb2NpdHkgZ2xvYmFsIG1hY3JvJ3MNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NjciPjQ2NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgUGFnZS5zZXRSZWRpcmVjdCB0byBjaGVjayBpZiByZWRpcmVjdCBwYXRoIHN0YXJ0cyB3aXRoIGNvbnRleHQgcGF0aC4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IENocmlzdG9waGUgRm9pcmV0DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDY4Ij40Njg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIGEgcmVncmVzc2lvbiB3aGVuIG1hbnVhbGx5IHNldHRpbmcgdGhlIFBhZ2UgcGF0aCB0byBhIEpTUC4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNDEiPjE0MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRGF0ZUZpZWxkJ3MgRnJlbmNoIHRyYW5zbGF0aW9uLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQWx2aW4gVG93bnNlbmQuDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQoNCiAgPGR0PjxhIG5hbWU9IjEuNSI+PC9hPlZlcnNpb24gMS41IC0gMiBOb3ZlbWJlciAyMDA4PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6IDE1cHg7IG1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4gDQogICAgICBUaGUgZm9sbG93aW5nIGlzc3VlcyB3ZXJlIHJlc29sdmVkIHNpbmNlIDEuNSBSQzM6DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBEdXRjaCBsYW5ndWFnZSBzdXBwb3J0LCBjb250cmlidXRlZCBieSBDaHJpc3RvcGhlciBIaWdod2F5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgRm9ybSB0byBwcm9jZXNzIGNvbnRyb2xzIGV2ZW4gaWYgdGhlaXIgbmFtZXMgaXMgbm90IGRlZmluZWQuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDYzIj40NjM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIENvbnRhaW5lclV0aWxzLmNvcHlUbyB3aGVyZSB0aGUgd3JvbmcgZ2V0dGVyIG1ldGhvZCBjb3VsZCBiZSB1c2VkDQogICAgICAgIHdoZW4gYSBkb21haW4gb2JqZWN0IGNvbnRhaW5zIG11bHRpcGxlIG92ZXJsb2FkZWQgZ2V0dGVyIG1ldGhvZHMuIFRoaXMNCiAgICAgICAgaXNzdWUgd2FzIHJhaXNlZCBieSBBbHZpbiBUb3duc2VuZA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2MSI+NDYxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDb2x1bW4gaW50ZXJuYWwgQ29tcGFyYXRvciB3aGljaCBkb2VzIG5vdCB0YWtlIHNvcnQgb3JkZXIgaW50bw0KICAgICAgICBjb25zaWRlcmF0aW9uIGZvciBub24gQ29tcGFyYWJsZSBpbnN0YW5jZXMNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NjIiPjQ2MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgUGFuZWwuZ2V0SWQoKSB0byByZXR1cm4gbnVsbCBpZiBuYW1lIGlzIG5vdCBkZWZpbmVkDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDY0Ij40NjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFZlbG9jaXR5VGVtcGxhdGVTZXJ2aWNlIHRvIGNhdGVyIGZvciBjdXN0b20gZGVmaW5lZCBWZWxvY2l0eSBsb2dnZXJzLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgVmlrcmFtIE5hdGFyYWphbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2NSI+NDY1PC9hPl0uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQoNCiAgPGR0PjxhIG5hbWU9IjEuNS1SQzMiPjwvYT5WZXJzaW9uIDEuNSBSQzMgLSAxOSBPY3RvYmVyIDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgSU1QT1JUQU5UIGJlIHN1cmUgdG8gcmVhZCB0aGUgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjMS41Ij51cGdyYWRlIHBhdGg8L2E+IHdoZW4gdXBncmFkaW5nIGZyb20gQ2xpY2sgMS40IG9yIGVhcmxpZXIuDQogICAgPC9kaXY+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIE5ldyBleGFtcGxlczoNCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtO21hcmdpbi1ib3R0b206IDJlbSI+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly93d3cuYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL3dpemFyZC93aXphcmQuaHRtIj4NCiAgICAgICAgICBXaXphcmQgZGVtbzwvYT4gc2hvd3MgaG93IHRvIGxldmVyYWdlIGEgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDJzMDguaHRtbCI+c3RhdGVmdWw8L2E+DQogICAgICAgICAgcGFnZSBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9QYW5lbC5odG1sIj5QYW5lbHM8L2E+DQogICAgICAgICAgdG8gY3JlYXRlIGEgcHJvY2VzcyBmbG93LiBFYWNoIFN0ZXAgaW4gdGhlIHByb2Nlc3MgaXMgcmVwcmVzZW50ZWQgYnkgYQ0KICAgICAgICAgIFBhbmVsIHdoaWNoIGlzIG1hbmFnZWQgYnkgdGhlIHN0YXRlZnVsIFBhZ2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vd3d3LmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9jb250cm9sL3BvcHVsYXRlLW9uLXNlbGVjdC5odG0iPg0KICAgICAgICAgIFBvcHVsYXRlIG9uIHNlbGVjdDwvYT4gc2hvd3MgaG93IGl0ZW1zIGluIG9uZSBjb21ibyBib3ggaXMgcG9wdWxhdGVkDQogICAgICAgICAgYmFzZWQgb24gdGhlIHNlbGVjdGVkIGl0ZW0gaW4gYW5vdGhlciB1c2luZyBKYXZhU2NyaXB0Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL3d3dy5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvdGFibGUvZWRpdC1mb3JtLXRhYmxlLmh0bSI+DQogICAgICAgICAgRm9ybVRhYmxlIGRlbW88L2E+IHNob3dzIGhvdyBhIEZvcm1UYWJsZSBjYW4gYmUgdXNlZCB0b2dldGhlciB3aXRoIGFuDQogICAgICAgICAgZXhpc3RpbmcgRm9ybS4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly93d3cuYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL3RyZWUvcGFnZS1saW5rLXRyZWUtcGFnZS5odG0iPg0KICAgICAgICAgIFBhZ2UgbGluayB0cmVlPC9hPiBwcm92aWRlcyBhIGRlbW9uc3RyYXRpb24gb2YgdXNpbmcgdGhlIFRyZWUgY29tcG9uZW50DQogICAgICAgICAgdG8gbGluayB0byBkaWZmZXJlbnQgcGFnZXMuDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIE5ldyBkb2N1bWVudGF0aW9uOg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaT4NCiAgICAgICAgQWRkZWQgYSBmdWxsIDxhIGhyZWY9ImNsaWNrLWR0ZC1leGFtcGxlLmh0bWwiPmNvbmZpZ3VyYXRpb24gZXhhbXBsZTwvYT4NCiAgICAgICAgY29udGFpbmluZyBhbGwgPHR0PmNsaWNrLnhtbDwvdHQ+IDxhIGhyZWY9ImNsaWNrLWR0ZC5odG1sIj5EVEQ8L2E+IGVsZW1lbnRzIGFuZCBhdHRyaWJ1dGVzLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6IDE1cHg7IG1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4gDQogICAgICBUaGUgZm9sbG93aW5nIGlzc3VlcyB3ZXJlIHJlc29sdmVkOg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgRm9ybVRhYmxlLnByb3BlcnRpZXMgY29udGFpbmluZyBhIG5ldyBwcm9wZXJ0eSA8c3BhbiBzdHlsZT0iY29sb3I6bmF2eTsiPmZvcm10YWJsZS1lcnJvcjwvc3Bhbj4uDQogICAgICAgIFdoZW4gYWRkaW5nIEZvcm1UYWJsZSB0byBhbiBleHRlcm5hbCBGcm9tLCB0aGUgPHNwYW4gc3R5bGU9ImNvbG9yOm5hdnk7Ij5mb3JtdGFibGUtZXJyb3I8L3NwYW4+DQogICAgICAgIHdpbGwgYmUgZGlzcGxheWVkIGlmIG9uZSBvZiB0aGUgRm9ybVRhYmxlIGZpZWxkcyBjb250YWlucyBhbiBlcnJvci4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlbmFtZWQgQ29udGFpbmVyVXRpbHMgbWV0aG9kIGdldEZpZWxkcyB0byBnZXRJbnB1dEZpZWxkcyB3aGljaCBiZXR0ZXIgcmVmbGVjdCBpdHMgYmVoYXZpb3INCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NTciPjQ1NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgVGFiYmVkRm9ybSBhbmQgVGFiYmVkQ2F5ZW5uZUZvcm0gdG8gaW1wb3J0IEphdmFTY3JpcHQgYW5kIENTUyBmcm9tIHRoZWlyDQogICAgICAgIHN1cGVyY2xhc3MuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBDaHJpc3RvcGhlIEZvaXJldA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ1MCI+NDUwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDYXllbm5lRm9ybSBwZXJmb3JtaW5nIG11bHRpcGxlIGluc2VydHMNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NTIiPjQ1MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRm9ybVRhYmxlIGR1cGxpY2F0ZSBIVE1MIGltcG9ydHMNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NTMiPjQ1MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgWG1sQ29uZmlnU2VydmljZSBub3QgZGVwbG95aW5nIEpBUiByZXNvdXJjZXMNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NTQiPjQ1NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgUGFnZS5zZXRSZWRpcmVjdCB0byBndWFyZCBhZ2FpbnN0IGR1cGxpY2F0ZSBjb250ZXh0IHBhdGhzLiBUaGlzIGlzc3VlDQogICAgICAgIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ1NiI+NDU2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDb3VudHJ5U2VsZWN0IHRvIGV4Y2x1ZGUgZHVwbGljYXRlIGNvdW50cmllcy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkDQogICAgICAgIGFuZCBmaXhlZCBieSBDaHJpc3RvcGhlciBIaWdod2F5DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDU4Ij40NTg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPGR0PjxhIG5hbWU9IjEuNS1SQzIiPjwvYT5EZXZlbG9wbWVudCBSZWxlYXNlIC0gVmVyc2lvbiAxLjUgUkMyIC0gMjkgU2VwdGVtYmVyIDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPiANCiAgICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIDxzcGFuIHN0eWxlPSJmb250LXdlaWdodDogYm9sZDsgY29sb3I6IG5hdnk7Ij5FbWVyZ2VuY3kgRml4PC9zcGFuPjogQ2xpY2sgdGhyb3dzIEZpbGVOb3RGb3VuZEV4Y2VwdGlvbiB3aGVuIGRlcGxveWluZyBjbGljay1leHRyYXMuamFyDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDQ4Ij40NDg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIENsaWNrIHNob3VsZCBhdXRvbWF0aWNhbGx5IHJlbW92ZSBhIENvbnRyb2wgZnJvbSBpdHMgcGFyZW50IHdoZW4gYWRkaW5nDQogICAgICAgIGl0IHRvIGFub3RoZXIgQ29udGFpbmVyLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ0OSI+NDQ5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCB1dGlsaXR5IG1ldGhvZHMgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwjZW5jb2RlVVJMKGphdmEubGFuZy5PYmplY3QpIj5DbGlja1V0aWxzLmVuY29kZVVSTDwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sI2RlY29kZVVSTChqYXZhLmxhbmcuT2JqZWN0KSI+Q2xpY2tVdGlscy5kZWNvZGVVUkw8L2E+DQogICAgICAgIGZvciBlbmNvZGluZyBhbmQgZGVjb2RpbmcgVVJMJ3MgdXNpbmcgdGhlICJVVEYtOCIgZW5jb2Rpbmcgc2NoZW1lLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8ZHQ+PGEgbmFtZT0iMS41LVJDMSI+PC9hPkRldmVsb3BtZW50IFJlbGVhc2UgLSBWZXJzaW9uIDEuNSBSQzEgLSAyOCBTZXB0ZW1iZXIgMjAwODwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+IA0KICAgICAgSU1QT1JUQU5UIGJlIHN1cmUgdG8gcmVhZCB0aGUgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjMS41Ij51cGdyYWRlIHBhdGg8L2E+IHdoZW4gdXBncmFkaW5nIGZyb20gQ2xpY2sgMS40IG9yIGVhcmxpZXIuDQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZWZhY3RvcmVkIFBhZ2luYXRvciBpbnRvIGEgbW9yZSBnZW5lcmljIGludGVyZmFjZSBjYWxsZWQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9SZW5kZXJhYmxlLmh0bWwiPlJlbmRlcmFibGU8L2E+DQogICAgICAgIHdoaWNoIGlzIGluZGVwZW5kZW50IG9mIGFueSBzcGVjaWZpYyBDb250cm9sDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDM0Ij40MzQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZCBuZXcgTGlua0RlY29yYXRvciBtZXRob2RzIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9MaW5rRGVjb3JhdG9yLmh0bWwjcmVuZGVyQWN0aW9uTGluayhvcmcuYXBhY2hlLmNsaWNrLnV0aWwuSHRtbFN0cmluZ0J1ZmZlciwgb3JnLmFwYWNoZS5jbGljay5jb250cm9sLkFic3RyYWN0TGluaywgb3JnLmFwYWNoZS5jbGljay5Db250ZXh0LCBqYXZhLmxhbmcuT2JqZWN0LCBqYXZhLmxhbmcuT2JqZWN0KSI+cmVuZGVyQWN0aW9uTGluazwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9MaW5rRGVjb3JhdG9yLmh0bWwjcmVuZGVyQWN0aW9uQnV0dG9uKG9yZy5hcGFjaGUuY2xpY2sudXRpbC5IdG1sU3RyaW5nQnVmZmVyLCBvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuQWN0aW9uQnV0dG9uLCBvcmcuYXBhY2hlLmNsaWNrLkNvbnRleHQsIGphdmEubGFuZy5PYmplY3QsIGphdmEubGFuZy5PYmplY3QpIj5yZW5kZXJBY3Rpb25CdXR0b248L2E+Lg0KICAgICAgICBUaGlzIGFsbG93cyBtb3JlIGZpbmUgZ3JhaW5lZCBjb250cm9sIG92ZXIgdGhlIHJlbmRlcmVkIGxpbmtzLCBmb3IgZXhhbXBsZQ0KICAgICAgICBtYW5pcHVsYXRpbmcgcmVxdWVzdCBwYXJhbWV0ZXJzLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ0NiI+NDQ2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGQgVGFibGUgUm93IGF0dHJpYnV0ZSBzdXBwb3J0IHRocm91Z2ggbmV3IG1ldGhvZCANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9UYWJsZS5odG1sI2FkZFJvd0F0dHJpYnV0ZXMoamF2YS51dGlsLk1hcCwgamF2YS5sYW5nLk9iamVjdCwgaW50KSI+YWRkUm93QXR0cmlidXRlczwvYT4uDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBIYW5zIFBvbw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQzMSI+NDMxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaWVsZCBlcnJvciBtZXNzYWdlcyBjYW4gbm93IGJlIHNwZWNpZmllZCBwZXIgaW5zdGFuY2UuDQogICAgICAgIFNlZSB0aGUgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI3NldEVycm9yTWVzc2FnZShqYXZhLmxhbmcuU3RyaW5nKSI+SmF2YURvYzwvYT4gZm9yIG1vcmUgZGV0YWlscy4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBSaWNhcmRvIExlY2hldGENCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MzMiPjQzMzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IHV0aWxpdHkgbWV0aG9kcw0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NvbnRhaW5lclV0aWxzLmh0bWwjY29weUNvbnRhaW5lclRvT2JqZWN0KG9yZy5hcGFjaGUuY2xpY2suY29udHJvbC5Db250YWluZXIsIGphdmEubGFuZy5PYmplY3QsIGphdmEudXRpbC5MaXN0KSI+Y29weUNvbnRhaW5lclRvT2JqZWN0PC9hPg0KICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Db250YWluZXJVdGlscy5odG1sI2NvcHlDb250YWluZXJUb09iamVjdChvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuQ29udGFpbmVyLCBqYXZhLmxhbmcuT2JqZWN0LCBqYXZhLnV0aWwuTGlzdCkiPmNvcHlPYmplY3RUb0NvbnRhaW5lcjwvYT4NCiAgICAgICAgdG8gc2VsZWN0aXZlbHkgZXhjbHVkZSBvciBpbmNsdWRlIGZvcm0gZmllbGRzIHdoZW4gcG9wdWxhdGluZyBkb21haW4gb2JqZWN0cy4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEtoYWxlZiBCZXNzYWloDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDQwIj40NDA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEVuY2Fwc3VsYXRlIGNvbnZlcnNpb24gbG9naWMgb2YgdGVtcGxhdGUgZXh0ZW5zaW9ucyBpbnNpZGUNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3NldFJlZGlyZWN0KGphdmEubGFuZy5TdHJpbmcpIj5QYWdlLnNldFJlZGlyZWN0KGphdmEubGFuZy5TdHJpbmcpPC9hPg0KICAgICAgICB3aGljaCBhbGxvd3Mgb25lIHRvIG92ZXJyaWRlIG9yIG92ZXJsb2FkIHRoZSBkZWZhdWx0IGJlaGF2aW9yLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgQmFsbGFyZA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQyOSI+NDI5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgVGFibGUgc28gdGhhdCBzdWJjbGFzc2VzIGNhbiBzcGVjaWZ5IGEgZGlmZmVyZW50DQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCNjb250cm9sTGluayI+Y29udHJvbExpbms8L2E+DQogICAgICAgIGltcGxlbWVudGF0aW9uIGJ5IG92ZXJyaWRpbmcgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9UYWJsZS5odG1sI2dldENvbnRyb2xMaW5rKCkiPmdldENvbnRyb2xMaW5rKCk8L2E+Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ0MiI+NDQyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCN0b0xhYmVsKGphdmEubGFuZy5TdHJpbmcpIj5DbGlja1V0aWxzLnRvTGFiZWw8L2E+IHRvIHJldHVybiBlbXB0eSBTdHJpbmcgKCIiKSBpZiBhcmd1bWVudCBpcyBudWxsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDQxIj40NDE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIERhdGVGaWVsZCB0byByZXR1cm4gYSBjYWNoZWQgRGF0ZSByZXByZXNlbnRhdGlvbiBvbiBzdWJzZXF1ZW50IHJldHJpZXZhbHMuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBUb3JlIEhhbHNldA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxNiI+MzE2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBSZWdleEZpZWxkIHZhbGlkYXRpb24gdG8gaWdub3JlIGVtcHR5IHZhbHVlcy4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IE11emFmZmVyIE96YWtjYQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQzNiI+NDM2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBUYWJiZWRQYW5lbCB0byB0cmlnZ2VyIHRoZSByZWdpc3RlcmVkIHRhYiBsaXN0ZW5lci4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IE1hcmNlbG8gR3Jhc3NpIEZyYW5jbyBNZWxnYedvLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQzMiI+NDMyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCByZWRpcmVjdCBhbmQgZm9yd2FyZCB0byBKU1AgdGVtcGxhdGVzLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQzNSI+NDM1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBIdG1sRmllbGRTZXQgdG8gcHJvcGVybHkgY2xvc2UgdGhlIGZpZWxkc2V0IGVuZCB0YWcuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBHaWxiZXJ0byBDLiBBbmRyYWRlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDI3Ij40Mjc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEFic3RyYWN0Q29udGFpbmVyRmllbGQgbm90IHRvIGJpbmQgaXRzIHJlcXVlc3QgcGFyYW1ldGVyLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgR2lsYmVydG8gQy4gQW5kcmFkZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQyOCI+NDI4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDb2x1bW4gd2hpY2ggZXhwb3NlZCBpdHMgaW50ZXJuYWwgQ29tcGFyYXRvciBhcyBwdWJsaWMgQVBJDQogICAgICAgIHRocm91Z2ggPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Db2x1bW4uaHRtbCNzZXRDb21wYXJhdG9yKGphdmEudXRpbC5Db21wYXJhdG9yKSI+Q29sdW1uLnNldENvbXBhcmF0b3IoQ29tcGFyYXRvcik8L2E+LA0KICAgICAgICBpbnN0ZWFkIG9mIGphdmEudXRpbC5Db21wYXJhdG9yLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQzMCI+NDMwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBMaW5rRGVjb3JhdG9yIG5vdCB0byBhZGQgVGFibGUgcGFyYW1ldGVycyB0byBQYWdlTGluaywgYXMgaXQgaXMgcmVkdW5kYW50Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSm9lbCBTY2htaWR0DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjcwIj4yNzA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPGR0PjxhIG5hbWU9IjEuNS1NMyI+PC9hPkRldmVsb3BtZW50IFJlbGVhc2UgLSBWZXJzaW9uIDEuNSBNMyAtIDE3IEF1Z3VzdCAyMDA4PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4gDQogICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTWFqb3IgcmVmYWN0b3JpbmcgdG8gaW1wcm92ZSBiYWNrd2FyZCBjb21wYXRpYmlsaXR5IGFuZCB1cGdyYWRlIHBhdGguDQogICAgICAgIFRoaXMgaW5jbHVkZXMgcmVtb3ZpbmcgQmFzaWNGb3JtIHdoaWNoIHdhcyBpbmNsdWRlZCBpbiAxLjUtTTEgYW5kIGFkZGluZw0KICAgICAgICBuZXcgQ29udHJvbHMgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0h0bWxGb3JtLmh0bWwiPkh0bWxGb3JtPC9hPg0KICAgICAgICBhbmQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0h0bWxGaWVsZFNldC5odG1sIj5IdG1sRmllbGRTZXQ8L2E+Lg0KICAgICAgICBZb3UgY2FuIGZpbmQgYW4gZXhhbXBsZSBvZiBIdG1sRm9ybSBpbiBhY3Rpb24gPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2Zvcm0vY29udGFjdC1kZXRhaWxzLmh0bSI+aGVyZTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBtdWx0aXBsZSBwYWdlIHBhY2thZ2UgZGVmaW5pdGlvbnMgaW4gY2xpY2sueG1sIGNvbmZpZ3VyYXRpb24uDQogICAgICAgIFNlZSB0aGUgY29uZmlndXJhdGlvbiB0b3BpYyA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2FwcGxpY2F0aW9uLW11bHRpcGxlLXBhY2thZ2VzIj5NdWx0aXBsZSBQYWdlcyBQYWNrYWdlczwvYT4NCiAgICAgICAgZm9yIG1vcmUgZGV0YWlscy4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFJpY2FyZG8gUi4gTGVjaGV0YQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyOCI+MzI4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBjb25maWd1cmFibGUgdGFibGUgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9UYWJsZVBhZ2luYXRvci5odG1sIj5QYWdpbmF0b3I8L2E+IHN1cHBvcnQNCiAgICAgICAgYW5kIGFuIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9UYWJsZUlubGluZVBhZ2luYXRvci5odG1sIj5JbmxpbmVQYWdpbmF0b3I8L2E+Lg0KICAgICAgICBBIG5ldyA8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvdGFibGUvdGFibGUtcGFnaW5hdG9yLmh0bSI+ZXhhbXBsZTwvYT4NCiAgICAgICAgc2hvd3MgdGhlIGRpZmZlcmVudCBQYWdpbmF0b3Igb3B0aW9ucyBhdmFpbGFibGUuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBHdXN0YXYgV2ViZXINCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zOTAiPjM5MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgcmVhZG9ubHkgYW5kIGRpc2FibGVkIHN1cHBvcnQgdG8gRmllbGRTZXQuIElmIGVuYWJsZWQgRmllbGRzIGNvbnRhaW5lZA0KICAgICAgICBpbiBGaWVsZFNldCB3aWxsIGJlIGRpc2FibGVkIG9yIG1hZGUgcmVhZG9ubHkuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDIzIj40MjM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIFRhYmxlIGZvb3RlciByZW5kZXJpbmcgc3VwcG9ydCwgc28gdGhhdCBjb2x1bW4gdG90YWxzIGNhbiBiZSByZW5kZXJlZCBpbiBhIHRhYmxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDI1Ij40MjU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIFRhYmxlIHJlbmRlcmluZyBwZXJmb3JtYW5jZSBpbiB0aGUgb3JkZXIgb2YgMjUtNDUlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgcmVuZGVyaW5nIHBlcmZvcm1hbmNlIGJ5IGNhY2hpbmcgdGhlIENsaWNrVXRpbHMgDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sI2dldFJlc291cmNlVmVyc2lvbkluZGljYXRvcihvcmcuYXBhY2hlLmNsaWNrLkNvbnRleHQpIj5yZXNvdXJjZSB2ZXJzaW9uIGluZGljYXRvcjwvYT4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MTIiPjQxMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgUGFnZSBhbmQgUGFnZUltcG9ydHMgdG8gYWxsb3cgYSBQYWdlcyB0byBvcHRpbWl6ZSB0aGVpciBIVE1MIGltcG9ydHMuDQogICAgICAgIFBsZWFzZSBzZWUgQ2xpY2sgRXhhbXBsZXMgZm9yIGEgZGVtb25zdHJhdGlvbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM2MyI+MzYzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBpc3N1ZSB3aGVyZSBTZWxlY3QgdmFsaWRhdGlvbiBjYW4gdGhyb3cgQ2xhc3NDYXN0RXhjZXB0aW9uIA0KICAgICAgICB3aGVuIG9wdGlvbiBsaXN0IGNvbnRhaW5zIGFuIE9wdGlvbkdyb3VwLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVyIGJ5IENocmlzdG9waGUgRm9pcmV0DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzc0Ij4zNzQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIGlzc3VlIHdoZXJlIENvbnRhaW5lciBjYW4gYmUgYWRkZWQgdG8gaXRzZWxmLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVyIGJ5IEhhcnJ5IFdpc3NpYWsNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MTQiPjQxNDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgUGFnZSBzZXJpYWxpemF0aW9uIGlzc3VlcyB3aXRoIG5vbiBzZXJpYWxpemFibGUgRm9ybWF0IGFuZCBQYWdlSW1wb3J0IG9iamVjdHMuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZXIgYnkgQWxleGVpIFNva29sb3YNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MTYiPjQxNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgaXNzdWUgd2hlcmUgQ2F5ZW5uZUZvcm0gY2xlYXJWYWx1ZXMoKSB3YXMgaGlkZGVuIGRhdGEgb2JqZWN0IGNsYXNzbmFtZS4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllciBieSBXaXNraW5nIEp1IFl1IFd1DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDE3Ij40MTc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIGlzc3VlIHdoZXJlIFRhYmJlZFBhbmVsIHdhcyBpbnZva2luZyB0aGUgYWN0aXZlUGFuZWwncyBvbkluaXQoKSBtZXRob2QgdHdpY2UuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZXIgYnkgV2lza2luZyBKdSBZdSBXdQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQyMCI+NDIwPC9hPl0uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxkdD48YSBuYW1lPSIxLjUtTTIiPjwvYT5EZXZlbG9wbWVudCBSZWxlYXNlIC0gVmVyc2lvbiAxLjUgTTIgLSAyMCBKdWx5IDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPiANCiAgICBJTVBPUlRBTlQgYmUgc3VyZSB0byByZWFkIHRoZSA8YSBocmVmPSJ1cGdyYWRlLXBhdGguaHRtbCMxLjUiPnVwZ3JhZGUgcGF0aDwvYT4gd2hlbiB1cGdyYWRpbmcgZnJvbSBDbGljayAxLjQgb3IgZWFybGllci4NCiAgICA8cC8+DQogICAgQ2xpY2sgMS41IE0yIGludHJvZHVjZWQgbWFqb3IgZW5oYW5jZW1lbnRzIHRvIENvbnRyb2wgbGlzdGVuZXIgc3VwcG9ydC4NCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIE5ldyBDb250cm9sIGxpc3RlbmVyIHN1cHBvcnQgdGhyb3VnaCB0aGUgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQWN0aW9uTGlzdGVuZXIuaHRtbCI+QWN0aW9uTGlzdGVuZXI8L2E+IGludGVyZmFjZS4NCiAgICAgICAgVGhpcyBjb250cm9sIGxpc3RlbmVyIHN0eWxlIHByb3ZpZGVzIGNvbXBpbGUgdGltZSBzYWZldHkgYW5kIHN1cHBvcnRzIGNvZGUgcmVmYWN0b3JpbmcgdG9vbHMuDQogICAgICAgIA0KICAgICAgPHByZSBjbGFzcz0icHJldHR5cHJpbnQiPg0KcHVibGljIGNsYXNzIE15UGFnZSBleHRlbmRzIFBhZ2Ugew0KDQogICAgcHVibGljIHZvaWQgb25Jbml0KCkgew0KICAgICAgICBTdWJtaXQgc3VibWl0ID0gbmV3IFN1Ym1pdCgic3VibWl0Iik7DQogICAgICAgIA0KICAgICAgICBzdWJtaXQuc2V0QWN0aW9uTGlzdGVuZXIobmV3IEFjdGlvbkxpc3RlbmVyKCkgew0KICAgICAgICAgICAgcHVibGljIGJvb2xlYW4gb25BY3Rpb24oQ29udHJvbCBzb3VyY2UpIHsNCiAgICAgICAgICAgICAgICAvLyBQZXJmb3JtIHN1Ym1pdCBhY3Rpb24gYW5kIHJldHVybiB0cnVlIHRvIGNvbnRpbnVlIHByb2Nlc3NpbmcNCiAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsNCiAgICAgICAgICAgIH0NCiAgICAgICAgfSk7DQogICAgfQ0KfSA8L3ByZT4NCiAgICAgIE5vdGUgdGhhdCB0aGUgc291cmNlIENvbnRyb2wgaXMgcGFzc2VkIGluIGFzIGFuIGFyZ3VtZW50IHRvIHRoZSBvbkFjdGlvbiBtZXRob2QuIA0KICAgICAgRm9yIHZlcnkgY29tcGxleCBzY2VuYXJpb3MgaXQgaXMgdXNlZnVsIHRvIGtub3cgd2hpY2ggQ29udHJvbCB0cmlnZ2VyZWQgdGhlIGV2ZW50DQogICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM2OSI+MzY5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbnRyb2R1Y2UgYSB0d28gcGhhc2UgbGlzdGVuZXIgZGlzcGF0Y2ggbWVjaGFuaXNtLiBEdXJpbmcgdGhlIG9uUHJvY2VzcyBldmVudCwNCiAgICAgICAgQ29udHJvbCBsaXN0ZW5lcnMgd2lsbCBiZSByZWdpc3RlcmVkIG9uIHRoZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9BY3Rpb25FdmVudERpc3BhdGNoZXIuaHRtbCI+QWN0aW9uRXZlbnREaXNwYXRjaGVyPC9hPg0KICAgICAgICBhbmQgdHJpZ2dlcmVkIGFmdGVyIHRoZSBvblByb2Nlc3MgZXZlbnQgZmluaXNoLiBUaGUgbmV0IGVmZmVjdCBvZiB0aGlzIGNoYW5nZQ0KICAgICAgICBpcyB0aGF0IHdoZW4gQ29udHJvbCBsaXN0ZW5lcnMgYXJlIHRyaWdnZXJlZCwgYWxsIHJlcXVlc3QgdmFsdWVzIGhhdmUgYmVlbiBib3VuZCB0byBDb250cm9scywNCiAgICAgICAgYW5kIGNhbiBzYWZlbHkgYmUgcmVmZXJyZWQgdG8gZnJvbSB0aGUgbGlzdGVuZXIgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNjUiPjM2NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgYnV0dG9uIHN1cHBvcnQgdG8gRmllbGRTZXQsIHNvIHRoYXQgYnV0dG9ucyBjYW4gYmUgcmVuZGVyZWQgaW5zaWRlDQogICAgICAgIEZpZWxkU2V0cy4gVGhpcyBjaGFuZ2UgaGFzIGJlZW4gZW5hYmxlZCBieSB0d28gcGhhc2UgcHJvY2Vzc2luZyB3aGljaA0KICAgICAgICBlbnN1cmVzIGFsbCBGaWVsZFNldCBmaWVsZHMgYXJlIHByb2Nlc3NlZCBiZWZvcmUgYnV0dG9uIGxpc3RlbmVycyBhcmUgaW52b2tlZA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQwMSI+NDAxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICA8L3VsPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4gDQogICAgVGhlIGZvbGxvd2luZyBpcyBhIGxpc3Qgb2YgZW5oYW5jZW1lbnRzIGFuZCBidWdzIGZpeGVzOiANCiAgICA8L2Rpdj4NCgk8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGEgbmV3IDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9QYWdlQnV0dG9uLmh0bWwiPlBhZ2VCdXR0b248L2E+IGNvbnRyb2wNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zOTIiPjM5MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW50cm9kdWNlZCBhIG5ldyByZXNvdXJjZSBkZXBsb3ltZW50IHN0cmF0ZWd5IGZvciA8ZW0+SmFyczwvZW0+IGNvbnRhaW5pbmcNCiAgICAgICAgUGFnZSBhbmQgQ29udHJvbCByZXNvdXJjZXMuIFdoZW4gQ2xpY2sgc3RhcnRzIHVwLCBpdCBzY2FucyBlYWNoIEphciBmb3VuZA0KICAgICAgICBpbiB0aGUgd2ViIGxpYiBmb2xkZXIgKHdlYmFwcC9XRUItSU5GL2xpYikgZm9yIGVudHJpZXMgc3RhcnRpbmcgd2l0aCAnTUVUQS1JTkYvd2ViLycuDQogICAgICAgIEFsbCBmaWxlcyBmb3VuZCB1bmRlciAnTUVUQS1JTkYvd2ViLycgd2lsbCBiZSBjb3BpZWQgdmVyYmF0aW0gdG8gdGhlIHdlYg0KICAgICAgICBhcHBsaWNhdGlvbiBmb2xkZXIuDQogICAgICAgIDxwLz4NCiAgICAgICAgU2VlIHRoZSBzZWN0aW9uIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAzLmh0bWwjZGVwbG95aW5nLWN1c3RvbS1yZXNvdXJjZXMiPkRlcGxveWluZyBDdXN0b20gUmVzb3VyY2VzPC9hPg0KICAgICAgICBmb3IgbW9yZSBkZXRhaWwuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzkzIj4zOTM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZCBuZXcgbWV0aG9kIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9DaGVja2JveFRyZWUuaHRtbCNzZXRTZWxlY3RDaGlsZE5vZGVzKGJvb2xlYW4pIj5DaGVja2JveFRyZWUuc2V0U2VsZWN0Q2hpbGROb2RlczwvYT4NCiAgICAgICAgdGhhdCBlbmFibGVzIHNlbGVjdGluZyBjaGlsZCBub2RlcyB3aGVuIHBhcmVudCBpcyBzZWxlY3RlZC4gVGhpcyBmZWF0dXJlDQogICAgICAgIG9ubHkgd29ya3MgaWYgdGhlIFRyZWUncyA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZS5odG1sI3NldEphdmFzY3JpcHRFbmFibGVkKGJvb2xlYW4pIj5KYXZhc2NyaXB0PC9hPg0KICAgICAgICBzdXBwb3J0IGlzIGVuYWJsZWQuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjA5Ij4yMDk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHByb3BlcnR5IGZpbGVzIHdpdGggdHJhbnNsYXRpb24gZm9yIHRoZSBSb21hbmlhbiBsYW5ndWFnZS4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBNYXJpdXMgUGV0cnVzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzYxIj4zNjE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZCB3aWR0aCBzdXBwb3J0IHRvIFRhYmJlZFBhbmVsIGNvbnRyb2wNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNzYiPjM3NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkIHN0YXRpYyBtZXRob2QgQ29udGV4dC5oYXNUaHJlYWRMb2NhbENvbnRleHQoKS4NCiAgICAgICAgVXNlZnVsIGZvciBjaGVja2luZyBpZiBhIENvbnRleHQgaXMgYXZhaWxhYmxlIG9uIHRoZSBDb250ZXh0IHN0YWNrDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzgyIj4zODI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZCBDbGlja1V0aWxzIGF1dG9Qb3N0UmVkaXJlY3QoKSBtZXRob2QgdG8gc3VwcG9ydCANCiAgICAgICAgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2VuLndpa2lwZWRpYS5vcmcvd2lraS9TQU1MIj5TQU1MPC9hPg0KICAgICAgICBpbnRlZ3JhdGlvbg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM5OCI+Mzk4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlVcGRhdGVkIENvbnRhaW5lciByZW5hbWluZyBtZXRob2QgQ29udGFpbmVyLmFkZChpbnQsIENvbnRyb2wpIHRvIENvbnRhaW5lci5pbnNlcnQoQ29udHJvbCwgaW50KSANCgkJdG8gYmV0dGVyIHJlZmxlY3QgdGhlIGludGVudGlvbg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM4MSI+MzgxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGUgRm9ybSB0byB1c2UgY29udHJvbCBtZXNzYWdlIGJ1bmRsZXMgZm9yIGxhYmVsIHJlcXVpcmVkIHByZWZpeC9zdWZmaXgNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zODMiPjM4MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlIEh0bWxTdHJpbmdCdWZmZXIgdG8gc3VwcG9ydCBtZXRob2QgY2hhaW5pbmcuIA0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGVtZXRyaW9zIEt5cmlha2lzDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzk2Ij4zOTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgTWVudSBzbyB0aGF0IGl0IGlzIG5vdyBvbmx5IGNhY2hlZCBpbiBwcm9kdWN0aW9uIG9yIHByb2ZpbGUgbW9kZXMuIA0KICAgICAgICBJbiBvdGhlciBkZXZlbG9wbWVudCBtb2RlcywgY2hhbmdlcyB0byBtZW51LnhtbCBpcyBzZWVuIGltbWVkaWF0ZWx5Lg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQwOCI+NDA4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIEFic3RyYWN0Q29udGFpbmVyRmllbGQgY29udHJvbCBtb3ZpbmcgaXQgdG8gQ2xpY2sgRXh0cmFzLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQxMCI+NDEwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBUYWJiZWRQYW5lbCBidWcgd2hlcmVieSBpbmFjdGl2ZSBwYW5lbCBIVE1MIGltcG9ydHMgYXJlIGluY2x1ZGVkIGluIHBhZ2UNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNjYiPjM2NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRmllbGRTZXQgcmVjdXJzaXZlIHJlbW92ZSBidWcNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNjciPjM2NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgYnVnIHdoZW4gbWFudWFsbHkgaW52YWxpZGF0aW5nIEh0dHBTZXNzaW9uDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzcxIj4zNzE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFByb3BlcnR5U2VsZWN0IGFkZCBvcmRlcmluZyB0byBxdWVyeSBidWcNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNzIiPjM3MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgbWVzc2FnZSBwcm9wZXJ0aWVzIHRvIHJlc29sdmUgYWxsIHBhcmVudCBtZXNzYWdlcw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM3MyI+MzczPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBMYWJlbHMgbm90IHJlbmRlcmluZyBpbiBhIEZpZWxkU2V0IGJ1Zw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM3NyI+Mzc3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBGb3JtIHJlbW92ZUZpZWxkIHRocm93cyBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb24gYnVnDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzc4Ij4zNzg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIEZpZWxkU2V0IHJlc3RvcmluZyBGaWVsZFNldCBhYmlsaXR5IHRvIHNldCBudW1iZXIgb2YgdGFibGUgY29sdW1ucyANCgkJdGhlIEZpZWxkU2V0IGlzIHJlbmRlcmVkIHdpdGgNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNzkiPjM3OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgYnVnIHdoZXJlIEZvcm1hdCBpcyBub3QgYXZhaWxhYmxlIGluIHRlbXBsYXRlIG9mIHN0YXRlZnVsIHBhZ2VzLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQwOSI+NDA5PC9hPl0uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxkdD48YSBuYW1lPSIxLjUtTTEiPjwvYT5EZXZlbG9wbWVudCBSZWxlYXNlIC0gVmVyc2lvbiAxLjUgTTEgLSAxOCBNYXkgMjAwODwvZHQ+DQogIDxkZD4NCiAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICBJTVBPUlRBTlQgYmUgc3VyZSB0byByZWFkIHRoZSA8YSBocmVmPSJ1cGdyYWRlLXBhdGguaHRtbCMxLjUiPnVwZ3JhZGUgcGF0aDwvYT4gd2hlbiB1cGdyYWRpbmcgZnJvbSBhIHByZXZpb3VzIHZlcnNpb24uDQogICAgPHAvPg0KICAgIENsaWNrIDEuNSAoY3VycmVudGx5IGluIGRldmVsb3BtZW50KSBpbnRyb2R1Y2VzIGltcG9ydGFudCBuZXcgZmVhdHVyZXMgaW5jbHVkaW5nOg0KICAgIDxwLz4NCiAgICA8dWwgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgPGxpIGNsYXNzPSJpdGVtIj48YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwM3MwNi5odG1sIj5Db250YWluZXI8L2E+IC0gbmV3IGludGVyZmFjZSBmb3IgYnVpbGRpbmcgYXJiaXRyYXJ5IGNvbXBsZXgsIGhpZXJhcmNoaWNhbCBDb250cm9scy48L2xpPg0KICAgICA8bGkgY2xhc3M9Iml0ZW0iPjxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvcGFja2FnZS1zdW1tYXJ5Lmh0bWwjc2VydmljZXMiPlNlcnZpY2VzPC9hPiAtIENsaWNrIGNvcmUgaGFzIGJlZW4gcmVmYWN0b3JlZCBpbnRvIHBsdWdnYWJsZSBzZXJ2aWNlcy48L2xpPg0KICAgICA8bGkgY2xhc3M9Iml0ZW0iPjxhIGhyZWY9Im1vY2stYXBpL292ZXJ2aWV3LXN1bW1hcnkuaHRtbCI+TW9jayBUZXN0IFN1cHBvcnQ8L2E+IC0gVW5pdCBhbmQgRnVuY3Rpb25hbCBUZXN0aW5nLjwvbGk+DQogICAgIDxsaSBjbGFzcz0iaXRlbSI+PGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BYnN0cmFjdENvbnRyb2wuaHRtbCI+QWJzdHJhY3RDb250cm9sPC9hPg0KICAgICAtIEFic3RyYWN0Q29udHJvbCB3YXMgZXh0ZW5kZWQgdG8gaW1wbGVtZW50IGFsbCBDb250cm9sIG1ldGhvZHMsIG1ha2luZyBpdCBlYXNpZXIgdG8gY3JlYXRlIGN1c3RvbSBjb250cm9scy48L2xpPg0KICAgIDwvdWw+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDoxLjVlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgIE5ldyBleGFtcGxlcyBhbmQgZG9jdW1lbnRhdGlvbiB3ZXJlIGFkZGVkOg0KICAgIDwvZGl2Pg0KICAgIDx1bD4NCiAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPk5ldyBleGFtcGxlczoNCiAgICAgIDx1bCBzdHlsZT0icGFkZGluZy10b3A6IDVweDsiPg0KICAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2Zvcm0vZXh0cmEtY29udHJvbHMtZm9ybS5odG0iPkNvdW50cnkgU2VsZWN0IGZpZWxkPC9hPg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICA8bGk+DQogICAgICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2Zvcm0vY29udGFjdC1kZXRhaWxzLmh0bSI+Q3VzdG9tIEZvcm0gTGF5b3V0IHVzaW5nIENvbnRhaW5lcnM8L2E+DQogICAgICAgICA8L2xpPg0KICAgICAgICAgPGxpPg0KICAgICAgICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3LmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9mb3JtL2V4dHJhLWNvbnRyb2xzLWZvcm0uaHRtIj5WaXJ0dWFsIEtleWJvYXJkIGZpZWxkPC9hPg0KICAgICAgICAgPC9saT4NCiAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvZ2VuZXJhbC9leGNlbC1leHBvcnQuaHRtIj5FeGNlbCBFeHBvcnQgRGVtbzwvYT4NCiAgICAgICAgIDwvbGk+DQogICAgICAgICA8bGk+DQogICAgICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2pzcC9lZGl0LWN1c3RvbWVyLmh0bSI+SlNQIC0gRWRpdCBDdXN0b21lcjwvYT4NCiAgICAgICAgIDwvbGk+DQogICAgICAgICA8bGk+DQogICAgICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2pzcC9uYXZpZ2F0aW9uLWEuaHRtIj5KU1AgLSBOYXZpZ2F0aW9uPC9hPg0KICAgICAgICAgPC9saT4NCiAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvanNwL211bHRpLXBhdGgtZGVtby5odG0iPkpTUCAtIE11bHRpIFBhdGggRGVtbzwvYT4NCiAgICAgICAgIDwvbGk+DQogICAgICA8L3VsPg0KICAgICA8L2xpPg0KICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+TmV3IGRvY3VtZW50YXRpb246DQogICAgIDx1bCBzdHlsZT0icGFkZGluZy10b3A6IDVweDsiPg0KICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAzczA2Lmh0bWwjY29udGFpbmVyIj5Db250YWluZXI8L2E+DQogICAgICAgICA8L2xpPg0KICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAzczA3Lmh0bWwjbGF5b3V0Ij5UZW1wbGF0ZSB2cyBDb250YWluZXIgbGF5b3V0PC9hPg0KICAgICAgICAgPC9saT4NCiAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9zZXJ2aWNlL3BhY2thZ2Utc3VtbWFyeS5odG1sIj5DbGljayBSdW50aW1lIFNlcnZpY2VzPC9hPg0KICAgICAgICAgPC9saT4NCiAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICA8YSBocmVmPSJtb2NrLWFwaS9vdmVydmlldy1zdW1tYXJ5Lmh0bWwiPk1vY2sgVGVzdCBTdXBwb3J0PC9hPg0KICAgICAgICAgPC9saT4NCiAgICAgPC91bD4NCiAgICA8L2xpPg0KICAgPC91bD4NCiAgPC9kaXY+DQogIDxwLz4NCiAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tdG9wOjEuNWVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICBBIG5ldyA8YSBocmVmPSJjbGljay1vbmxpbmUuaHRtbCNwb3dlcmVkIj5Qb3dlcmVkIGJ5IENsaWNrPC9hPiBzZWN0aW9uIHdhcyBhZGRlZC4NCiAgIElmIHlvdSB3YW50IHRvIGVubGlzdCB5b3VyIHNpdGUsIHBsZWFzZSBzZW5kIGEgbWFpbCB0byBvbmUgb2Ygb3VyIA0KICAgPGEgaHJlZj0iY2xpY2stb25saW5lLmh0bWwjbWFpbGluZy1saXN0cyI+TWFpbGluZyBMaXN0czwvYT4gb3IgZGlyZWN0bHkgdG8gInNhYm9iMSBhdCBnbWFpbC5jb20iLg0KICAgPHAvPg0KICAgVGhlIGZvbGxvd2luZyBpcyBhIGxpc3Qgb2YgZW5oYW5jZW1lbnRzIGFuZCBidWdzIGZpeGVzOg0KICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIEFkZGVkIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuZnJlZW1hcmtlci5vcmciPkZyZWVtYXJrZXI8L2E+IHN1cHBvcnQgYXMgYW4gDQoJICAgIGFsdGVybmF0aXZlIHRlbXBsYXRpbmcgZW5naW5lIHRvIFZlbG9jaXR5LCB3aXRoIG5ldyANCgkgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9zZXJ2aWNlL0ZyZWVtYXJrZXJUZW1wbGF0ZVNlcnZpY2UuaHRtbCI+RnJlZW1hcmtlclRlbXBsYXRlU2VydmljZTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCSAgICBBZGRlZCBhIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9Db3VudHJ5U2VsZWN0Lmh0bWwiPkNvdW50cnkgU2VsZWN0PC9hPg0KCSAgICBjb250cm9sIGJhc2VkIG9uIHRoZSBKREsncyBvd24gYnVpbHQgaW4gQ291bnRyeS9Mb2NhbGUgc3VwcG9ydC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIEFkZGVkIGEgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL1ZpcnR1YWxLZXlib2FyZC5odG1sIj5WaXJ0dWFsIEtleWJvYXJkPC9hPiANCgkgICAgY29udHJvbCB1c2luZyA8YSBocmVmPSJodHRwOi8vd3d3LmdyZXl3eXZlcm4uY29tL2NvZGUvanMva2V5Ym9hcmQuaHRtbCI+R3JleVd5dmVybjwvYT4gSmF2YVNjcmlwdCBsaWJyYXJ5Lg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgQWRkZWQgc3VwcG9ydCBmb3Igc2V0dGluZyBGb3JtICANCgkgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjZ2V0QWN0aW9uVVJMKCkiPmFjdGlvbjwvYT4gDQoJICAgIFVSTCBhdHRyaWJ1dGUuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBFcmRlbSBHdW5heQ0KCSAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxOSI+MzE5PC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCSAgICBBZGRlZCBzdXBwb3J0IGZvciBQYWdlIEhUTUwJaW1wb3J0cyB3aXRoIGEgbmV3IDx0dD5nZXRIdG1sSW1wb3J0cygpPC90dD4gDQoJICAgIG1ldGhvZC4gVGhpcyBlbmFibGVzIFBhZ2VzIHRvIHByb2dyYW1hdGljYWxseSBkZWZpbmUgSFRNTCBpbXBvcnRzIHdoaWNoDQoJICAgIHdpbGwgYmUgaW5jbHVkZWQgaW4gYSBib3JkZXIgdGVtcGxhdGUgdXNpbmcgdGhlIFBhZ2VJbXBvcnRzIG9iamVjdC4NCgkgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZyaXplbGxlDQoJICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzI5Ij4zMjk8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZCBQYWdlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzZXRUZW1wbGF0ZShqYXZhLmxhbmcuU3RyaW5nKSI+c2V0VGVtcGxhdGUoU3RyaW5nKTwvYT4NCiAgICAgICAgbWV0aG9kIHRvIGVuYWJsZSBkeW5hbWljIGNoYW5naW5nIG9mIGEgcGFnZSBib3JkZXIgdGVtcGxhdGUuIFRoaXMgaXNzdWUNCiAgICAgICAgd2FzIHJhaXNlZCBieSBIdXkgRG8gDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzUzIj4zNTM8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3NldFBhdGgoamF2YS5sYW5nLlN0cmluZykiPlBhZ2Uuc2V0UGF0aDwvYT4gdG8gaGFuZGxlIEpTUCByZXNvdXJjZXMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgSHV5IERvLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE0MSI+MTQxPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBIaWJlcm5hdGUgQW5ub2NhdGlvbkNvbmZpZ3VyYXRpb24uIFRoaXMgaXNzdWUgd2FzIGZpeGVkIGJ5IEplYW4tRnJhbmNvaXMuDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzU1Ij4zNTU8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcHJvdmVkIEZpbGVVcGxvYWQgc3VwcG9ydC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyNiI+MzI2PC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXByb3ZlIEZpbGUgVXBsb2FkIHN1cHBvcnQgd2l0aCBuZXcgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svc2VydmljZS9GaWxlVXBsb2FkU2VydmljZS5odG1sIj5GaWxlVXBsb2FkU2VydmljZTwvYT4gY2xhc3MuDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzI2Ij4zMjY8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFByb3BlcnR5U2VsZWN0IHdoaWNoIGlzIG5vdCByZXNldCB0byBvcmlnaW5hbCB2YWx1ZS4gVGhpcyBpcyB3YXMgcmFpc2VkIGJ5IFRvcmUgSGFsc2V0DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzE3Ij4zMTc8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIENheWVubmUgMy4wTTMgRGF0YU9iamVjdFV0aWxzIGlzc3VlIGluIENheWVubmVGb3JtIHdoZW4gdXNpbmcgSkRLIDEuNS4gDQogICAgICAgIEFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9DYXllbm5lVXRpbHMuaHRtbCI+Q2F5ZW5uZVV0aWxzPC9hPiBoZWxwZXIgY2xhc3MNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNDIiPjM0MjwvYT5dLg0KCSAgPC9saT4NCiAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgIFVwZ3JhZGVkIHRoZSBmb2xsb3dpbmcgbGlicmFyaWVzOg0KICAgICA8dWwgc3R5bGU9Im1hcmdpbi10b3A6MWVtOyI+DQogICAgICAgPGxpPmNvbW1vbnMtbGFuZyAyLjEgLT4gY29tbW9ucy1pbyAyLjQ8L2xpPg0KICAgICAgIDxsaT5jb21tb25zLWlvIDEuMyAtPiBjb21tb25zLWlvIDEuNDwvbGk+DQogICAgICAgPGxpPmNvbW1vbnMtZmlsZXVwbG9hZCAxLjIgLT4gY29tbW9ucy1maWxldXBsb2FkIDEuMi4xPC9saT4NCiAgICAgICA8bGk+SGliZXJuYXRlIDMuMS4zIC0+IEhpYmVybmF0ZSAzLjIuNjwvbGk+DQogICAgICAgPGxpPlNwcmluZyAxLjIuOSAtPiBTcHJpbmcgMi41LjQ8L2xpPg0KICAgICA8L3VsPg0KICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+UmVtb3ZlZCBzdXBwb3J0IGZvciBDYXllbm5lIDEuMi54LjwvbGk+DQogIAk8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD48YSBuYW1lPSIxLjQuMiI+PC9hPlZlcnNpb24gMS40LjIgLSAxMiBBcHJpbCAyMDA4PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRXhjbHVkZVBhZ2Ugc2hvdWxkIGJlIGEgcHVibGljIGNsYXNzDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQ2Ij4zNDY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIE1hdmVuIGFydGlmYWN0cyBwYWNrYWdpbmcNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNDgiPjM0ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgc2xpZ2h0IHBlcmZvcm1hbmNlIGRlZ3JhZGF0aW9uDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQ5Ij4zNDk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgUGFnZUxpbmsgdG8gY2hhbmdlIGV4dGVuc2lvbiA8dHQ+anNwPC90dD4gdG8gPHR0Pmh0bTwvdHQ+DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzUyIj4zNTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgRGF0ZUZpZWxkIGFuZCBDaGFydEZpZWxkcyB0byBpbmNsdWRlIHRoZSBqYXZhc2NyaXB0IDx0dD5jb250cm9sLmpzPC90dD4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNTQiPjM1NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBEYXRlRmllbGQgd2hpY2ggcHJvZHVjZWQgZHVwbGljYXRlIHN0eWxlc2hlZXQgbGlua3MuDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzU2Ij4zNTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPGR0PjxhIG5hbWU9IjEuNC4xIj48L2E+VmVyc2lvbiAxLjQuMSAtIDMwIE1hcmNoIDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPiBEZXZlbG9wZXINCiAgICA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL3NhYm9iLyI+Qm9iIFNjaGVsbGluazwvYT4NCiAgICBhY2NlcHRzIG5ldyBQcm9qZWN0IExlYWRlciByb2xlIGZvciB0aGUgQ2xpY2sgcHJvamVjdC48YnIvPg0KICAgIE5ldyBkZXZlbG9wZXIgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0icmljYXJkb2xlY2hldGFAdXNlcnMuc291cmNlZm9yZ2UubmV0Ij5SaWNhcmRvIExlY2hldGE8L2E+IGpvaW5zIHRoZSBDbGljayBwcm9qZWN0Lg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IG1ldGhvZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwjaXNBamF4UmVxdWVzdCgpIj5Db250ZXh0LmlzQWpheFJlcXVlc3QoKTwvYT4NCiAgICAgICAgd2hpY2ggZW5hYmxlcyBjb25kaXRpb25hbCBjaGVja2luZyBmb3IgQWpheCByZXF1ZXN0cy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCVVwZ3JhZGVkZWQgdG8gU2NyaXB0YWN1bG91cyAxLjguMSB0byBmaXggYXV0byBmb3JtIHN1Ym1pdC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFuZHkgS2V5Lg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMzNiI+MzM2PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBkZXBsb3ltZW50IG9mIHJlc291cmNlcyB3aGVuIHNlcnZsZXQgY29udGFpbmVyIGRvZXMgbm90IHVucGFjayB3YXIuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQwIj4zNDA8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIHNlbmRSZWRpcmVjdCB0byBjb252ZXJ0IDxlbT4uanNwPC9lbT4gZXh0ZW5zaW9uIHRvIDxlbT4uaHRtPC9lbT4gd2hlbiByZWRpcmVjdGluZyB0byBhIEpTUCBwYWdlLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMzOCI+MzM4PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBGb3JtIDx0dD5jbGVhclZhbHVlcygpPC90dD4gdG8gZXhjbHVkZSBjZXJ0YWluIEhpZGRlbkZpZWxkcyBmcm9tIGJlaW5nIGNsZWFyZWQuDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzM3Ij4zMzc8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIEZvcm0gYWN0aW9uIGluY29ycmVjdCB3aGVuIHVzaW5nIEpTUC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IENoYXMgRXJpY2tzb24uDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzM0Ij4zMzQ8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI29uU3VibWl0Q2hlY2sob3JnLmFwYWNoZS5jbGljay5QYWdlLCBqYXZhLmxhbmcuU3RyaW5nKSI+Rm9ybS5vblN1Ym1pdENoZWNrKCk8L2E+DQogICAgICAgIHRvIGlnbm9yZSBBamF4IGNhbGxzLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSXZhbiBGdXJkaS4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMzMiPjMzMzwvYT5dLg0KCSAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRm9ybSBhbmQgRmllbGRTZXQgY29sdW1uIGxheW91dCBidWcgDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzMxIj4zMzE8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFRhYmxlIGNvbHVtbiBzb3J0aW5nIGlzc3VlIHdpdGggc3RyaW5nIHZhbHVlcy4gDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBCZW4gWW91bmcNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNDQiPjM0NDwvYT5dLg0KCSAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgVGFibGUgc3R5bGUgaXNzdWVzIHdpdGggc29ydGVkIGNvbHVtbnMgDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQ1Ij4zNDU8L2E+XS4NCgkgIDwvbGk+DQogIAk8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD48YSBuYW1lPSIxLjQiPjwvYT5WZXJzaW9uIDEuNCAtIDIgTWFyY2ggMjAwODwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCVVwZGF0ZWQgQ2F5ZW5uZSBjb250cm9scyB0byBzdXBwb3J0IENheWVubmUgdmVyc2lvbiAzLjAuDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBDYXllbm5lRm9ybSA8dHQ+c2F2ZSgpPC90dD4gbWV0aG9kIGluc2VydGluZyBtdWx0aXBsZSBuZXcgZW50cmllcyBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgVG9yZSBIYWxzZXQNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMDciPjMwNzwvYT5dLg0KCSAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgVGFibGUgaW52YWxpZCBoYW5kbGluZyBwYXJhbXMgYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFNhdG9zaGkgVGFrYXRhDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzA4Ij4zMDg8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIERhdGVGaWVsZCByZWFkb25seSBKYXZhU2NyaXB0IGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFRvcmUgSGFsc2V0DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzA5Ij4zMDk8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIERhdGVGaWVsZCBEdXRjaCBDYWxlbmRhciB0cmFuc2xhdGlvbi4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEhhcnJ5IFdpc3NpYWsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMTAiPjMxMDwvYT5dLg0KCSAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRGF0ZUZpZWxkIDx0dD4kaW1wb3J0czwvdHQ+IHVzYWdlIEphdmFTY3JpcHQgYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSXRvdSBBa2loaXJvDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzExIj4zMTE8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIGJ1ZyB3aGVyZSBjaGFyc2V0IGVuY29kaW5nIGJlaW5nIHNldCBhZnRlciByZXF1ZXN0IHBhcmFtZXRlcnMgYXJlIHJlYWQuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgUmljYXJkbyBMZWNoZXRhDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzEyIj4zMTI8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFRocmVhZExvY2FsIENvbnRleHQgZm9yd2FyZGluZyBidWcgb24gSmV0dHkgNS4xLiouDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMTQiPjMxNDwvYT5dLg0KCSAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgJ3NjcmlwdC5hY3Vsby51cycgQWpheC5BdXRvY29tcGxldGVyIGJ1ZyB3aXRoIElFLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSXRvdSBBa2loaXJvDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzIyIj4zMjI8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIENvbXByZXNzaW9uU2VydmxldFJlc3BvbnNlV3JhcHBlciBOUEUgYnVncyBvbiBXZWJTcGhlcmUgYW5kIEpldHR5Lg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUmljYXJkbyBMZWNoZXRhIGFuZCBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzIzIj4zMjM8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiAJICANCgk8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDEuNCBSQzMgLSA2IEZlYnJ1YXJ5IDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2ZpbHRlci9QZXJmb3JtYW5jZUZpbHRlci5odG1sIj5QZXJmb3JtYW5jZUZpbHRlcjwvYT4gDQoJCXRvIHNpZ25pZmljYW50bHkgaW1wcm92ZSB0aGUgcGVyZm9ybWFuY2Ugb2YgQ2xpY2sgYXBwbGljYXRpb25zDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjg0Ij4yODQ8L2E+LCA8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjkwIj4yOTA8L2E+XS4NCgkJPHAvPg0KCQlDbGljayBGcmFtZXdvcmsgbm93IHN1cHBvcnRzIA0KCQk8YSBocmVmPSJodHRwOi8vZGV2ZWxvcGVyLnlhaG9vLmNvbS9wZXJmb3JtYW5jZS9ydWxlcy5odG1sIj5FeGNlcHRpb25hbCBQZXJmb3JtYW5jZTwvYT4NCiAgICAgICAgYmVzdCBwcmFjdGljZXMgZm9yIHNwZWVkaW5nIHVwIHlvdXIgd2ViIHNpdGUuDQoJCVRoaXMgZmlsdGVyIGNvbWJpbmVkIHdpdGggZnJhbWV3b3JrIGNoYW5nZXMgZW5hYmxlIENsaWNrIGFwcGxpY2F0aW9ucyB0byBnZXQNCgkJYW4gR3JhZGUgQSByYXRpbmcgd2l0aCBZYWhvbydzIFlTbG93Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDJzMDguaHRtbCI+U3RhdGVmdWwgUGFnZXM8L2E+IHRvcGljIGFuZA0KCQljb21wbGV0ZWQgZnJhbWV3b3JrIHN1cHBvcnQgZm9yIHNlcmlhbGl6aW5nIHN0YXRlZnVsIFBhZ2VzIGFuZCB0aGVpciBjb250cm9scy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIG5ldyBBSkFYIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9BdXRvQ29tcGxldGVUZXh0RmllbGQuaHRtbCI+QXV0b0NvbXBsZXRlVGV4dEZpZWxkPC9hPiB3aGljaCBwcm92aWRlcyBHb29nbGUgc3VnZ2VzdCBzdHlsZSBsb29rdXBzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IFRhYmxlIENTUyBjbGFzcyBzdHlsZXM6IDx0dD5ibHVlMSwgYmx1ZTIsIG9yYW5nZTEsIG9yYW5nZTI8L3R0Pg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJVXBkYXRlZCA8dHQ+Rm9ybS5jb3B5RnJvbSgpPC90dD4gdG8gYWxpZ24gd2l0aCBzcGVjaWFsIE1hcCBoYW5kbGluZyBvZiA8dHQ+Rm9ybS5jb3B5VG8oKTwvdHQ+Lg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNzgiPjI3ODwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgVXBkYXRlZCBGb3JtIHN1Ym1pdCBjaGVjayB0byBoYW5kbGUgbXVsdGlwbGUgZm9ybXMgcGVyIHBhZ2UuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3OSI+Mjc5PC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCSAgICBVcGRhdGVkIFRhYmxlIHRvIG51bGxpZnkgcm93TGlzdCBwcm9wZXJ0eS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjgzIj4yODM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgPHR0PkNvbnRyb2xzPC90dD4gdG8gdXNlIHRoZSBuZXcgQVBJIA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0Q29udHJvbC5odG1sI2FkZFN0eWxlQ2xhc3MoamF2YS5sYW5nLlN0cmluZykiPmFkZFN0eWxlQ2xhc3MoU3RyaW5nKTwvYT4gYW5kDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWJzdHJhY3RDb250cm9sLmh0bWwjc2V0U3R5bGUoamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLlN0cmluZykiPnNldFN0eWxlKFN0cmluZywgU3RyaW5nKTwvYT4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yODYiPjI4NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgVXBkYXRlZCBKUyBhZGRMb2FkRXZlbnQoKSB0byB1c2UgUHJvdG90eXBlIEZpeGVkIGV4Y2VwdGlvbiB3aGVuIHVzaW5nIDx0dD5Gb3JtLm9uU2VjdXJ0eUNoZWNrPC90dD4gaW4gYSBzdGF0ZWZ1bCBmb3JtLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI0NSI+MjQ1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBUYWJsZSA8dHQ+aXNpPC90dD4gc3R5bGUgcmVuZGVyaW5nIHByb2JsZW1zLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSi5GLiBaYXJhbWENCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOTYiPjE5NjwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRGF0ZUZpZWxkIEphdmFTY3JpcHQgZm9ybWF0IHBhdHRlcm4gYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSXRvdSBBa2loaXJvIGFuZCBmaXhlZCBieSBJdG91IEFraWhpcm8gYW5kIE5hb2tpIFRha2V6b2UNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNTAiPjI1MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgRml4ZWQgZXhjZXB0aW9uIHdoZW4gdXNpbmcgPHR0PkZvcm0ub25TZWN1cnR5Q2hlY2s8L3R0PiBpbiBhIHN0YXRlZnVsIGZvcm0uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBKb2VsIFNjaG1pZHQNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNjciPjI2NzwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgUGlja0xpc3QgbXVsdGlwbGUgc2VsZWN0aW9uIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI4MCI+MjgwPC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBDb250ZXh0IGxlYWsgdW5kZXIgaGVhdnkgdXNhZ2UuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI4MiI+MjgyPC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBQYWdlIGF1dG9tYXBwaW5nIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFNlcCBhbmQgUmljYXJkbyBMZWNoZXRhDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjc3Ij4yNzc8L2E+LA0KCQkgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI5NCI+Mjk0PC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBMaW51eCBSZXNvdXJjZUJ1bmRsZSBjbGFzc2xvYWRpbmcgYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgVmljdG9yDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjkzIj4yOTM8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFRyZWUgZW5jb2RlVVJMIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBUaG9tYXMgQmVybmhhcmQNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMDEiPjMwMTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgVGFibGUgbWVtb3J5IGFsbG9jYXRpb24gYnVnIGZvciBsYXJnZSBwYWdlZCByb3dMaXN0cy4NCgkJVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBOYW9raSBUYWtlem9lDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzA1Ij4zMDU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQ2F5ZW5uZSBsaWJyYXJ5IHRvIHZlcnNpb24gMi4wLjQsIHdoaWNoIGZpeGVzIGEgbWVtb3J5IGxlYWsgaW4gDQogICAgICAgIHZlcnNpb24gMi4wMy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEJvYiBTY2hlbGxpbmsgDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjgxIj4yODE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgdGhlIEphdmFTY3JpcHQgUHJvdG90eXBlIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjUuMCBhbmQgJ3NjcmlwdC5hY3Vsby51cycgdG8gdmVyc2lvbiAxLjcuMC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDEuNCBSQzIgLSAyIEphbnVhcnkgMjAwODwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIHByb3BlcnR5IGZpbGVzIHdpdGggdHJhbnNsYXRpb24gZm9yIHRoZSBDemVjaCBsYW5ndWFnZS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBEYXZpZCBNYXJrbw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIzOCI+MjQyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBmYWNpbGl0eSB0byBsb2FkIDx0dD5jbGljay54bWw8L3R0PiBmcm9tIGNsYXNzIHBhdGggaWYgbm90IGZvdW5kDQoJCXVzZXIgPHR0PldFQi1JTkY8L3R0Pi4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBBbmRyZSBCcmVtZXINCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNzMiPjI3MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgQ2FsZW5kYXIgcHJvcGVydHkgYW5kIEpTIGZpbGVzIHdpdGggdHJhbnNsYXRpb24gZm9yIHRoZSBEdXRjaCBsYW5ndWFnZS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBIYXJyeSBXaXNzaWFrDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjc1Ij4yNzU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIFRhYmxlIHByb3BlcnR5IDx0dD5jbGVhclJvd0xpc3RPbkRlc3Ryb3k8L3R0Pi4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEpvZWwgU2NobWlkdA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI2OCI+MjY4PC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlVcGRhdGVkIEV4dGVybmFsTGluayBjb250cm9sIHJlbmFtaW5nIG1ldGhvZCA8dHQ+c2V0UGFnZUNsYXNzPC90dD4gdG8gPHR0PnNldFRhcmdldFBhdGg8L3R0Pi4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEl0b3UgQWtpaGlybyANCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNDQiPjI0NDwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJVXBkYXRlZCBGaWVsZFNldCB0byBzdXBwb3J0IHJlbmRlcmluZyB3aXRob3V0IGEgTGVnZW5kLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSm9lbCBTY2htaWR0DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjU3Ij4yNTc8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCVVwZGF0ZWQgTWVzc2FnZU1hcCB0byBpbXByb3ZlIGNhY2hlIGtleS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3NCI+Mjc0PC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBidWcgd2hlcmUgZG91YmxlICJjbGFzcyIgYXR0cmlidXRlcyBhcmUgcmVuZGVyZWQgaW4gSFRNTCBmb3IgRmllbGQgDQoJCWNvbnRyb2xzIGlmIHZhbGlkYXRpb24gaXMgZmFpbGVkLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgU2h1byBHZW5nIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIzMyI+MjMzPC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCB0cmFuc2xhdGlvbiBlcnJvcnMgZm9yIEZyZW5jaCBwcm9wZXJ0aWVzLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFBhdHJpY2sgVGFsYm90IA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIzOCI+MjM4PC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBDbGlja1V0aWxzIDx0dD5jb3B5Rm9ybVRvT2JqZWN0KCk8L3R0PiBtZXRob2QgPHR0Pk1hcDwvdHQ+IHN1cHBvcnQuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBIYXJyeSBXaXNzaWFrIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIzOSI+MjM5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBKU1AgcGFnZSByZWN1cnNpb24gYnVnIHdoZW4gbm90IGJvcmRlciB0ZW1wbGF0ZSBkZWZpbmVkLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIzNyI+MjM3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBEYXRhQ29udGV4dEZpbHRlciBhbHdheXMgY3JlYXRpbmcgSHR0cFNlc3Npb24gYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRmxvcmluIFQuUEFUUkFTQ1UNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNDAiPjI0MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ2xpY2tBcHAgTlBFIGJ1ZyBvbiBPQzRKIGFwcGxpY2F0aW9uIHNlcnZlci4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEhhcnJ5IFdpc3NpYWsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNDgiPjI0ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ29udGV4dCBoYW5kbGluZyBvZiBtdWx0aXZhbHVlIHBhcmFtZXRlcnMgb24gbXVsdGlwYXJ0IGZpbGUgdXBsb2FkIHJlcXVlc3RzLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI1MiI+MjUyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBjbGFzc2xvYWRlciBpc3N1ZSB3aGVuIGNsaWNrIEpBUlMgbm90IGNvbnRhaW5lZCBpbiB3ZWIgYXBwbGljYXRpb24uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBIYXJyeSBXaXNzaWFrDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjU2Ij4yNTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIG1pc3NpbmcgbGFuZ3VhZ2UgcHJvcGVydGllcy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNjkiPjI2OTwvYT4sDQoJCSA8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjcxIj4yNzE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIEZvcm1UYWJsZSBtaXNzaW5nIGZpZWxkIGltcG9ydHMgYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRnJhbudvaXMtWGF2aWVyIEd1aWxsZW1ldHRlDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjcyIj5DTEstMjcyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBDbGlja1V0aWxzIDx0dD5nZXRNaW1pZVR5cGUoKTwvdHQ+IG5vdCBzdXBwb3J0aW5nIHVwcGVyIGNhc2UgZmlsZSBleHRlbnNpb25zLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQmVuIFdhcm5lcg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3NiI+Q0xLLTI3NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMS40IFJDMSAtIDE1IFNlcHRlbWJlciAyMDA3PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wb3J0YW50IENoYW5nZQ0KCQl0aGUgUGFnZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc3RhdGVmdWwiPnN0YXRlZnVsPC9hPiBwcm9wZXJ0eQ0KCQlhZGRlZCB0byBzdXBwb3J0IHBlcnNpc3RlbmNlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wb3J0YW50IENoYW5nZSANCgkJdGhlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCI+Q29udGV4dDwvYT4gb2JqZWN0DQoJCWlzIG5vdyBhdmFpbGFibGUgaW4gUGFnZSBhbmQgQ29udHJvbCBjb25zdHJ1Y3RvcnMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXBvcnRhbnQgQ2hhbmdlIA0KCQlhZGRlZCBDb250cm9sIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNvbkluaXQoKSI+b25Jbml0KCk8L2E+IA0KCQlpbml0aWFsaXphdGlvbiBldmVudCBoYW5kbGVyLg0KCQlBcyB0aGUgPHR0PnNldENvbnRleHQoKTwvdHQ+IG1ldGhvZCBoYXMgYmVlbg0KCQlyZW1vdmVkIGFueSBjb250cm9sIGluaXRpYWxpemF0aW9uIGNvZGUgY29udGFpbmVkIGluIHRoaXMgbWV0aG9kIHNob3VsZCBiZQ0KCQltaWdyYXRlZCB0byB0aGUgbmV3IGNvbnRyb2wgPHR0Pm9uSW5pdCgpPC90dD4gbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wb3J0YW50IENoYW5nZSANCgkJdGhlIFhNTCBjb25maWd1cmVkIHJvb3QgTWVudSBpdGVtIGlzIG9idGFpbmVkIHZpYSB0aGUgc3RhdGljIG1ldGhvZCANCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCNnZXRSb290TWVudSgpIj5nZXRSb290TWVudSgpPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcG9ydGFudCBDaGFuZ2UgDQoJCW11bHRpcGFydCBmaWxlIHVwbG9hZCByZXF1ZXN0cyBhcmUgbm93IHByb2Nlc3NlZCB1c2luZyBhIGdsb2JhbGx5IGNvbmZpZ3VyZWQgQ29tbW9ucyBGaWxlVXBsb2FkDQoJCWNsYXNzLiBQbGVhc2Ugc2VlIHRoZSANCgkJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svc2VydmljZS9Db21tb25zRmlsZVVwbG9hZFNlcnZpY2UuaHRtbCI+Q29tbW9uc0ZpbGVVcGxvYWRTZXJ2aWNlPC9hPg0KCQlmb3IgbW9yZSBkZXRhaWxzLiBUaGlzIGNoYW5nZSBlbmFibGVzIGZvciByZXF1ZXN0IHBhcmFtZXRlciBhdXRvIGJpbmRpbmcNCgkJb24gbXVsdGlwYXJ0IGZpbGUgdXBsb2FkIHJlcXVlc3RzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wb3J0YW50IENoYW5nZSANCgkJQ2xpY2sgRXh0cmFzIG5vdyBzdXBwb3J0cyBBcGFjaGUgQ2F5ZW5uZSAyLnggcmF0aGVyIHRoYW4gT2JqZWN0c3R5bGUgQ2F5ZW5uZSAxLjIueCANCgkJYnkgZGVmYXVsdC4gTm90ZSBiYWNrd2FyZCBjb21wYXRpYmlsaXR5IENheWVubmUgMS4yLnggSkFSUyBhcmUgcHJvdmlkZSBpbiB0aGUgZGlzdCBkaXJlY3RvcnkuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBDb250cm9sIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNvblJlbmRlcigpIj5vblJlbmRlcigpPC9hPiANCgkJcmVuZGVyIGV2ZW50IGhhbmRsZXIuIFRoaXMgbWV0aG9kIGlzIHVzZWZ1bCBmb3IgUGFuZWwgY29udHJvbHMgcG9wdWxhdGluZyB0YWJsZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBDb250cm9sIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNvbkRlc3Ryb3koKSI+b25EZXN0cm95KCk8L2E+IA0KCQlkZXN0cm95IGV2ZW50IGhhbmRsZXIuIFRoaXMgbWV0aG9kIGlzIHVzZWZ1bCBmb3IgY29udHJvbHMgdG8gZnJlZSByZXNvdXJjZXMsIHdoZW4gdGhlIGNvbnRyb2xzDQoJCWFyZSBjb250YWluZWQgaW4gc3RhdGVmdWwgcGFnZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9FeHRlcm5hbExpbmsuaHRtbCI+RXh0ZXJuYWxMaW5rPC9hPiBjb250cm9sLiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgQWJzdHJhY3RDb250cm9sIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWJzdHJhY3RDb250cm9sLmh0bWwjZ2V0UGFnZSgpIj5nZXRQYWdlKCk8L2E+IG1ldGhvZC4gDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIENvbnRleHQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI2dldFJlcXVlc3RQYXJhbWV0ZXJWYWx1ZXMoKSI+Z2V0UmVxdWVzdFBhcmFtZXRlclZhbHVlcygpPC9hPiBtZXRob2QuIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBDb250ZXh0IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNpc0dldCgpIj5pc0dldCgpPC9hPiBtZXRob2QuIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBGaWVsZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwjaGVscCI+aGVscDwvYT4gcHJvcGVydHkgDQogICAgICAJdG8gcmVuZGVyIGhlbHAgdGV4dCB0byB0aGUgcmlnaHQgaGFuZCBzaWRlIG9mIGZpZWxkcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgTWVudSA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTWVudS5odG1sI2ltYWdlU3JjIj5pbWFnZVNyYzwvYT4gcHJvcGVydHkgDQogICAgICAJdG8gc3VwcG9ydCBmb3IgcmVuZGVyaW5nIGltZyBpY29ucyBpbiBtZW51cy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlbmFtZWQgQ29udGV4dCBtZXRob2QgPHR0PmdldFJlcXVlc3RQYXJhbWV0ZXJzPC90dD4gdG8NCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI2dldFJlcXVlc3RQYXJhbWV0ZXJNYXAoKSI+Z2V0UmVxdWVzdFBhcmFtZXRlck1hcDwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCVVwZGF0ZSBsb2NhbGl6YXRpb24gY2xpY2stY29udHJvbF9wdF9CUi5wcm9wZXJ0aWVzIHByb3ZpZGVkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjIxIj4yMjE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgU2VsZWN0LCBDaGVja0xpc3QgYW5kIFBpY2tMaXN0IGNvbnRyb2xzIHRvIHVzZSBzdGFuZGFyZA0KICAgICAgICA8dHQ+Z2V0U2VsZWN0ZWRWYWx1ZXMoKTwvdHQ+IG1ldGhvZC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IENocmlzdG9waGUgRk9JUkVUDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMjEiPjIyNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlSZW1vdmVkIFBhZ2UgYW5kIENvbnRyb2wgPHR0PnNldENvbnRleHQoKTwvdHQ+IG1ldGhvZHMuIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlSZW1vdmVkIEZpbGVGaWVsZCA8dHQ+ZmlsZVVwbG9hZDwvdHQ+IHByb3BlcnR5LiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFBhZ2UgY29udHJvbCBhdXRvYmluZGluZyBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBDaHJpc3RvcGhlIEZPSVJFVA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE5NSI+MTk1PC9hPiwgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE5NSI+MjEyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBDbGlja0FwcCBub3QgcGlja2luZyB1cCBuZXcgUGFnZSBjbGFzc2VzIGR5bmFtaWNhbGx5Lg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMjIiPjIyMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBGb3JtIGlzRm9ybVN1Ym1pc3Npb24oKSBtZXRob2QgZmFpbHMgd2hlbiBjYWxsZWQgdHdpY2Ugd2l0aCBtdWx0aS1wYXJ0IHJlcXVlc3QgYnVnDQogICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIyNCI+MjI0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIG1hY3JvLnZtIGlzIG9ubHkgYXZhaWxhYmxlIGlmIHdhciBpcyB1bnBhY2tlZCBidWcuIFRoaXMgaXNzdWUgd2FzDQogICAgICAJcmFpc2VkIGJ5IEFuZHJ1cyBBZGFtY2hpayBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluaw0KICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMzAiPjIzMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgT0dOTCBEb3VibGUgdG8gQmlnRGVjaW1hbCB0eXBlIGNvbnZlcnNpb24gYnVnLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQNCgkJYnkgQmVuIFdhcm5lciBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHA6Ly9qaXJhLm9wZW5zeW1waG9ueS5jb20vYnJvd3NlL09HTkwtMTIyIj5PR05MLTEyMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBDYXllbm5lIGxpYnJhcnkgdG8gdmVyc2lvbiAyLjAuMy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDEuMy4xIC0gMTEgSnVuZSAyMDA3PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvQ2F5ZW5uZUZvcm0uaHRtbCI+Q2F5ZW5uZUZvcm08L2E+IA0KICAgICAgICB0byBoYW5kbGUgbm9uIGludGVnZXIgcHJpbWFyeSBrZXkgdmFsdWVzLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgVG9yZSBIYWxzZXQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMTEiPjIxMTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgUmFkaW9Hcm91cCBpcyBzdGlsbCBhY3RpdmUgd2hlbiBzZXQgaXQgdG8gZGlzYWJsZWQgYnVnLiANCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IENocmlzdG9waGUgRk9JUkVUDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMTgiPjIxODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRm9ybSBmaWxlIHVwbG9hZCBjaGFyYWN0ZXIgZW5jb2RpbmcgTlBFLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgUm9zZW5zdGFyaw0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjIwIj4yMjA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQ29tbW9ucyBGaWxlVXBsb2FkIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjIuIEZpeGVzIGJ1ZyB3aGVyZSBmaWxlIA0KICAgICAgICBuYW1lcyBhcmUgYmVpbmcgY29udmVydGVkIGludG8gbG93ZXJjYXNlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBDb21tb25zIElPIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDEuMi4zLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBTcHJpbmcgbGlicmFyeSB0byB2ZXJzaW9uIDEuMi45Lg0KICAgICAgPC9saT4NCiAgICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjMgLSA1IEp1bmUgMjAwNzwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcG9ydGFudCBDaGFuZ2UgDQoJCXRoZSA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMwMi5odG1sI2FjdGl2aXR5LWRpYWdyYW0iPlBhZ2VzPC9hPiBldmVudCBleGVjdXRpb24gb3JkZXINCgkJaGFzIGNoYW5nZWQgd2l0aCB0aGUgPHR0Pm9uU2VjdXJpdHlDaGVjaygpPC90dD4gbWV0aG9kIG5vdyBpbnZva2VkIGJlZm9yZSANCgkJdGhlIDx0dD5vbkluaXQoKTwvdHQ+IG1ldGhvZC4gVGhlIGJlbmVmaXQgb2YgdGhpcyBpcyB0aGF0IHRoZSA8dHQ+b25Jbml0KCk8L3R0PiANCgkJaXMgb25seSBpbnZva2VkIGlmIHRoZSByZXF1ZXN0IGhhcyBwYXNzZWQgdGhlIDx0dD5vblNlY3VyaXR5Q2hlY2soKTwvdHQ+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCANCiAgICAgIAk8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUGlja0xpc3QuaHRtbCI+UGlja0xpc3Q8L2E+IGNvbnRyb2wuDQogICAgICAJVGhpcyBjb250cm9sIHdhcyBjcmVhdGVkIGJ5IE5hb2tpIFRha2V6b2UgDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOTQiPjE5NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL1RyZWUuaHRtbCI+VHJlZTwvYT4gY29udHJvbCBjbGllbnQgc2lkZSBqYXZhc2NyaXB0IGZ1bmN0aW9uYWxpdHkuIA0KCQlUaGlzIHdhcyBwcm92aWRlZCBieSBCb2IgU2NoZWxsaW5rIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE4NiI+MTg2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAyLmh0bWwjYXBwbGljYXRpb24tYXV0b2JpbmRpbmciPmF1dG9iaW5kaW5nPC9hPiBjb25maWd1cmF0aW9uIG9wdGlvbi4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQWhtZWQgTW9ob21iZSANCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE5OSI+MTk5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCA8dHQ+dGFiaW5kZXg8L3R0PiBzdXBwb3J0IHRvIA0KCQk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0TGluay5odG1sIj5BYnN0cmFjdExpbms8L2E+IGFuZCANCgkJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sIj5GaWVsZDwvYT4gY29udHJvbHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBGb3JtICANCgkJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjZGVmYXVsdEZpZWxkU2l6ZSI+ZGVmYXVsdEZpZWxkU2l6ZTwvYT4gcHJvcGVydHkuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXByb3ZlZCA8dHQ+dHJhY2U8L3R0PiBsZXZlbCBsb2dnaW5nIHRvIGRldGFpbCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwiPlBhZ2U8L2E+IGV2ZW50IGV4ZWN1dGlvbiBvcmRlci4gDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXByb3ZlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvRW1haWxGaWVsZC5odG1sIj5FbWFpbEZpZWxkPC9hPiB2YWxpZGF0aW9uLiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUNoYW5nZWQgZGVmYXVsdCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCI+Rm9ybTwvYT4gZXJyb3JQb3N0aW9uIGZyb20gPHR0PiJtaWRkbGUiPC90dD4gdG8gPHR0PiJ0b3AiPC90dD4uIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL0NheWVubmVGb3JtLmh0bWwiPkNheWVubmVGb3JtPC9hPiANCgkJaGFuZGxpbmcgb2YgbmV3IG9iamVjdHMgYnVnLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQW5kcnVzIEFkYW1jaGlrIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTczIj43MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWxlRmllbGQuaHRtbCI+RmlsZUZpZWxkPC9hPiANCgkJY29uZmlndXJhdGlvbnMgbm90IGJlIGFwcGxpZWQgaW4gY2VydGFpbiBzY2VuYXJpb3MuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgU2FkYW5vcmkgSXRvIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE3OSI+MTc5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBQYWdlIHdpdGggdHdvIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCI+VGFibGU8L2E+DQoJICAgIGNvbnRyb2xzIHByb2R1Y2VzIHVubmVlZGVkIGNzcyBzdHlsZSB0ZXh0IGJ1Zy4gDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBKLkYuIFphcmFtYSAgDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTk3Ij4xOTc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9MaW5rRGVjb3JhdG9yLmh0bWwiPkxpbmtEZWNvcmF0b3I8L2E+IHRhYmxlIHNvcnRpbmcgc3VwcG9ydC4gDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBMb3VpcyBNYXJ0aW4gYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsgDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjA3Ij4yMDc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCI+VGFibGU8L2E+IGNvbHVtbiBzb3J0aW5nIGJ1Zy4gDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBMb3VpcyBNYXJ0aW4gYW5kIGZpeGVkIGJ5IE5hb2tpIFRha2V6b2UgIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIwOCI+MjA4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjIgLSAyMm5kIE1hcmNoIDIwMDc8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjAuNWVtOyI+IE5ldyBkZXZlbG9wZXINCiAgICA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL3NhYm9iLyI+Qm9iIFNjaGVsbGluazwvYT4NCiAgICBqb2lucyB0aGUgQ2xpY2sgcHJvamVjdC48L2Rpdj4gIA0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBjb250cm9scyANCiAgICAgIAk8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZS5odG1sIj5UcmVlPC9hPiBhbmQNCiAgICAgIAk8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvQ2hlY2tib3hUcmVlLmh0bWwiPkNoZWNrYm94VHJlZTwvYT4uDQogICAgICAJVGhlc2UgY29udHJvbHMgd2VyZSBjcmVhdGVkIGJ5IEJvYiBTY2hlbGxpbmsNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNjAiPjE2MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBjb250cm9scyBKU0JhckNoYXJ0LCBKU0xpbmVDaGFydCBhbmQgSlNQaWVDaGFydC4NCiAgICAgIAlUaGVzZSBjb250cm9scyB3ZXJlIGNyZWF0ZWQgYnkgQWhtZWQgTW9ob21iZS4NCiAgICAgICAgPHNwYW4gY2xhc3M9InJlZCI+VXBkYXRlOjwvc3Bhbj4gdGhlc2UgY29udHJvbHMgd2VyZSBtb3ZlZCB0byB0aGUNCiAgICAgICAgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9wL2NsaWNrLWNoYXJ0cy8iPkNsaWNrIENoYXJ0czwvYT4NCiAgICAgICAgcHJvamVjdC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgRmllbGQgY29udmVuaWVuY2UgbWV0aG9kcyBmb3Igc2V0dGluZyBzdHlsZSwgdGV4dC1hbGlnbiBhbmQgd2lkdGggSFRNTCBhdHRyaWJ1dGVzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgbXVsdGlwbGUgQWN0aW9uQnV0dG9uIHBhcmFtZXRlcnMsIHNlZSANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BY3Rpb25CdXR0b24uaHRtbCNzZXRQYXJhbWV0ZXIoamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLlN0cmluZykiPnNldFBhcmFtZXRlcigpPC9hPg0KICAgICAgICBmb3IgZGV0YWlscy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEFic3RyYWN0TGluaw0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0TGluay5odG1sI2ltYWdlU3JjIj5pbWFnZVNyYzwvYT4NCiAgICAgICAgcHJvcGVydHkgZm9yIHJlbmRlcmluZyBpbWcgaWNvbnMgaW5zaWRlIGxpbmtzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBjbGFzcyBoaWVyYXJjaHkgbWVzc2FnZXMgaW5oZXJpdGFuY2UgdG8gPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9NZXNzYWdlc01hcC5odG1sIj5NZXNzYWdlc01hcDwvYT4uDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFuZHJ1cyBBZGFtY2hpaw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc0Ij43NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgQWN0aW9uQnV0dG9uIHN1cHBvcnQgdG8gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0xpbmtEZWNvcmF0b3IuaHRtbCI+TGlua0RlY29yYXRvcjwvYT4uDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMzUiPjEzNTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgb3JkZXJpbmcgc3VwcG9ydCB0byA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvUHJvcGVydHlTZWxlY3QuaHRtbCI+UHJvcGVydHlTZWxlY3Q8L2E+Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNTQiPjE1NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgRmllbGRTZXQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZFNldC5odG1sI2NvbHVtbnMiPmNvbHVtbnM8L2E+IHByb3BlcnR5Lg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBMb3JlbnpvIE9yc2VsbGkNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNTgiPjE1ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgb3B0aW9uYWwgcHJvcGVydHkgdG8gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL1F1ZXJ5U2VsZWN0Lmh0bWwjb3B0aW9uYWwiPlF1ZXJ5U2VsZWN0PC9hPiBhbmQNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL1Byb3BlcnR5U2VsZWN0Lmh0bWwjb3B0aW9uYWwiPlByb3BlcnR5U2VsZWN0PC9hPiBjb250cm9scy4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgTG9yZW56byBPcnNlbGxpDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTU2Ij4xNTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgc3VwcG9ydCBmb3IgTmFtZWRRdWVyeSBvYmplY3RzIGluDQogICAgICAJPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL1Byb3BlcnR5U2VsZWN0Lmh0bWwjbmFtZWRRdWVyeSI+UHJvcGVydHlTZWxlY3Q8L2E+Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNjYiPjE2NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBJdGFsaWFuIGFuZCBGcmVuY2ggQ29sb3JQaWNrZXIgYW5kIFRlbGVwaG9uZUZpZWxkIHByb3BlcnRpZXMgcHJvdmlkZWQgYnkgTG9yZW56byBPcnNlbGxpDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTcxIj4xNzE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgQ2hpbmVzZSBsb2NhbGl6YXRpb24gcHJvcGVydGllcyBwcm92aWRlZCBieSBMYXJyeSBMaQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE3NyI+MTc3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCI+Q2xpY2tVdGlsczwvYT4gDQogICAgICAgIGNvb2tpZSBoYW5kbGluZyBtZXRob2RzLCBhbmQgY29udmVuaWVuY2UgbWV0aG9kcyBpbiB0aGUgQ29udGV4dCBjbGFzcy4NCiAgICAgIAlUaGVzZSBtZXRob2RzIHdlcmUgZGVycml2ZWQgZnJvbSB0aGUgQXRsYXNzaWFuIA0KICAgICAgCTxhIHRhcmdldD0iYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL29wZW5zb3VyY2UuYXRsYXNzaWFuLmNvbS9zZXJhcGgvYXBpZG9jcy9jb20vYXRsYXNzaWFuL3NlcmFwaC91dGlsL0Nvb2tpZVV0aWxzLmh0bWwiPkNvb2tpZVV0aWxzPC9hPg0KICAgICAgCWNsYXNzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCI+TWVudTwvYT4gcHJvcGVydGllcw0KICAgICAgICBleHRlcm5hbCBhbmQgdGFyZ2V0LCBhbmQgY2hhbmdlZCA8dHQ+dG9TdHJpbmcoKTwvdHQ+IG1ldGhvZCB0byByZW5kZXIgYW4gSFRNTCBhbmNob3IgdGFnLiANCiAgICAgICAgVGhlc2UgY2hhbmdlcyBzaW1wbGlmeSBtZW51IFZlbG9jaXR5IG1hY3Jvcy4NCiAgICAgICAgUGxlYXNlIG5vdGUgdGhlIDx0dD5pc1VzZXJJblJvbGVzKCk8L3R0PiBtZXRob2Qgbm93IHJldHVybnMgZmFsc2UgaWYgdGhlcmUgYXJlIG5vIHJvbGVzDQogICAgICAgIGRlZmluZWQgZm9yIHRoZSBtZW51IGl0ZW0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9EYXRhQ29udGV4dEZpbHRlci5odG1sIj5EYXRhQ29udGV4dEZpbHRlcjwvYT4gc3VwcG9ydCBmb3IgDQogICAgICAJc2Vzc2lvbiBvciByZXF1ZXN0IHNjb3BlIERhdGFDb250ZXh0IG9iamVjdHMsIGFuZCBjb250cm9saW5nIHRoZSB1c2Ugb2YgdGhlIENheWVubmUgc2hhcmVkIGNhY2hlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBDYXllbm5lIERBTy9TZXJ2aWNlIGJhc2UgY2xhc3MgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL0NheWVubmVUZW1wbGF0ZS5odG1sIj5DYXllbm5lVGVtcGxhdGU8L2E+DQogICAgICAJdG8gQ2xpY2sgRXh0cmFzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBhdXRvbWFwcGluZyBzdXBwb3J0IGZvciAvY2xpY2svZXJyb3IuaHRtIHBhZ2VzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgQ2xpY2tTZXJ2bGV0IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NsaWNrU2VydmxldC5odG1sI2NyZWF0ZUNsaWNrTG9nZ2VyKCkiPmNyZWF0ZUNsaWNrTG9nZ2VyKCk8L2E+IA0KICAgICAgICBtZXRob2QgdG8gc3VwcG9ydCBjdXN0b21pemluZyBDbGljayBydW50aW1lIGVuZ2luZSBsb2dnaW5nLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQm9iIFNjaGVsbGluay4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIENvbHVtbiA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NvbHVtbi5odG1sI3RpdGxlUHJvcGVydHkiPnRpdGxlUHJvcGVydHk8L2E+IA0KICAgICAgICBhdHRyaWJ1dGUgdG8gc3VwcG9ydCByZW5kZXJpbmcgJmx0O3RkJmd0OyB0aXRsZSBhdHRyaWJ1dGVzLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCA8YSBocmVmPSJjbGljay1pZGUuaHRtbCI+Q2xpY2tJREU8L2E+IGRvY3VtZW50YXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBQYWdlIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAyczAzLmh0bWwjcmVxdWVzdC1wYXJhbS1hdXRvLWJpbmRpbmciPlJlcXVlc3QgUGFyYW0gQXV0byBCaW5kaW5nPC9hPiBkb2N1bWVudGF0aW9uIHRvcGljLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgQmVzdCBQcmFjdGljZXMgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDVzMDIuaHRtbCNwYWNrYWdlcy1jbGFzc2VzIj5QYWNrYWdlcyBhbmQgQ2xhc3NlczwvYT4gZG9jdW1lbnRhdGlvbiB0b3BpYy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIHVzYWJpbGl0eSBvZiBGaWVsZCBsYWJlbHMsIHByb3ZpZGluZyBmaWVsZCBsYWJlbCBmb2N1cyBzdXBwb3J0Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZSBhbmQgZml4ZWQgYnkgU2FkYW5vcmkgSXRvDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTU5Ij4xNTk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJSW1wcm92ZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9JbWFnZVN1Ym1pdC5odG1sI3NyYyI+SW1hZ2VTdWJtaXQ8L2E+IA0KICAgICAgCXNyYyByZW5kZXJpbmcgYnkgcHJlZml4aW5nIGNvbnRleHQgcGF0aA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE2NSI+MTY1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUltcHJvdmVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQ29sdW1uLmh0bWwjZ2V0SGVhZGVyVGl0bGUoKSI+Q29sdW1uPC9hPiANCiAgICAgIAlpMThuIHN1cHBvcnQgZm9yIGhlYWRlciB0aXRsZXMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNzYiPjE3NjwvYT5dLg0KICAgICAgDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUltcHJvdmVkIEZvcm0gDQogICAgICAJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjZW5kVGFnKCkiPmVuZFRhZygpPC9hPiANCiAgICAgIAlyZW5kZXJpbmcgdG8gaW5jbHVkZSBKYXZhU2NyaXB0IGZvY3VzIGFuZCB2YWxpZGF0aW9uIGNvZGUuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCBUYWJsZSBjb2x1bW4gc29ydGluZy4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUltcHJvdmVkIGVycm9yIHJlcG9ydGluZyBmb3IgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9ucy4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUltcHJvdmVkIEFic3RyYWN0TGluayByZW5kZXJpbmcgb2YgZGlzYWJsZWQgbGlua3MsIG5vdyByZW5kZXIgYXMgYSBzcGFuIGVsZW1lbnQuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlSZWZhY3RvcmVkIERvdWJsZUZpZWxkLCBJbnRlZ2VyRmllbGQgYW5kIExvbmdGaWVsZCB0byBzdWJjbGFzcyANCiAgICAgIAk8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTnVtYmVyRmllbGQuaHRtbCI+TnVtYmVyRmllbGQ8L2E+LiANCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQWhtZWQgTW9ob21iZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEyMCI+MTIwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCVJlbW92ZWQgc3VwcG9ydCBmb3IgbG9nZ2luZyB0byBTZXJ2bGV0IGxvZy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgQWN0aW9uTGluayBzZXRWYWx1ZU9iamVjdCgpIG5vdCBzZXR0aW5nIG51bGwgdmFsdWVzLiANCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNTAiPjE1MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBtdWx0aXBsZSBGb3JtIHN1cHBvcnQgaW4gcGFnZXMgd2l0aCBhbiBmaWxlIHVwbG9hZCBmb3JtDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTUyIj4xNTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgcmVhZG9ubHkgc3VwcG9ydCBpbiA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NoZWNrYm94Lmh0bWwiPkNoZWNrYm94PC9hPiwNCiAgICAgIAk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1JhZGlvLmh0bWwiPlJhZGlvPC9hPiBhbmQNCiAgICAgIAk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1NlbGVjdC5odG1sIj5TZWxlY3Q8L2E+IGNvbnRyb2xzLiANCiAgICAgIAlUaGVzZSBpc3N1ZXMgd2VyZSByYWlzZWQgYnkgTG9yZW56byBPcnNlbGxpIGFuZCBEYXZpZCBGcml6ZWxsZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE1NSI+MTU1PC9hPiwNCiAgICAgICAgIDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNjQiPjE2NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBlcnJvciBwb3NpdGlvbiBzdXBwb3J0IGluIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9UYWJiZWRGb3JtLmh0bWwiPlRhYmJlZEZvcm08L2E+IGNvbnRyb2wuIA0KICAgICAgCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBMb3JlbnpvIE9yc2VsbGkNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNTciPjE1NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBkaWZmZXJlbmNlcyBvZiBKYXZhL0phdmFTY3JpcHQgZXJyb3IgbWVzc2FnZS4gDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBTYWRhbm9yaSBJdG8NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNjEiPjE2MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBmaXJzdCBkYXkgb2Ygd2VlayBidWcgaW4gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0RhdGVGaWVsZC5odG1sIj5EYXRlRmllbGQ8L2E+IGNvbnRyb2wuIA0KICAgICAgCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgU2FkYW5vcmkgSXRvDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTcwIj4xNzA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgRm9ybQ0KICAgICAgCTxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2NvcHlUbyhqYXZhLmxhbmcuT2JqZWN0KSI+Y29weVRvPC9hPiANCiAgICAgIAlNYXAgc3VwcG9ydC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IExvdWlzIE1hcnRpbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE3MiI+MTcyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIEZpbGVGaWVsZCBKYXZhU2NyaXB0IHZhbGlkYXRpb24gYnVnLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIA0KICAgICAgCWJ5IFNhZGFub3JpIEl0bw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE3OCI+MTc4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIFByb3BlcnR5U2VsZWN0IGFwcGxpZXMgb3JkZXJpbmcgdHdpY2UgYnVnLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgTGFycnkgQnVudG9uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTgzIj4xODM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgd3JvbmcgZm9ybSBIVE1MIGdlbmVyYXRpb24uIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xODkiPjE4OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlIFZlbG9jaXR5IGxpYnJhcnkgdG8gdmVyc2lvbiAxLjUtYmV0YTIuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDEuMi4yLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgDQogIDxkdD5WZXJzaW9uIDEuMSAtIDIyIE5vdmVtYmVyIDIwMDY8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjAuNWVtOyI+IE5ldyBkZXZlbG9wZXINCiAgICA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL3NoYWJlcm1hbi8iPlN0ZXBoZW4gSGFiZXJtYW48L2E+DQogICAgam9pbnMgdGhlIENsaWNrIHByb2plY3QuPC9kaXY+ICANCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgRm9ybSBmaWVsZCB3aWR0aCBncmlkIGxheW91dCByZW5kZXJpbmcgb3B0aW9uLiBTZWUgdGhlIEZvcm0gDQogICAgICAJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjYWRkKG9yZy5hcGFjaGUuY2xpY2suY29udHJvbC5GaWVsZCwgaW50KSI+YWRkKGZpZWxkLCB3aWR0aCk8L2E+IG1ldGhvZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgVGFibGUgQ29sdW1uIHNvcnRpbmcgc3VwcG9ydC4gU2VlIHRoZSBDb2x1bW4gDQogICAgICAJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Db2x1bW4uaHRtbCNzb3J0YWJsZSI+c29ydGFibGU8L2E+IHByb3BlcnR5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBDb2x1bW4gY29udmVuaWVuY2UgbWV0aG9kcyBmb3Igc2V0dGluZyB3aWR0aCwgdGV4dC1hbGlnbiwgDQogICAgICAJdmVydGljYWwtYWxpZ24gYXR0cmlidXRlcywgYW5kIHNldHRpbmcgZGF0YSBhbmQgaGVhZGVyIHN0eWxlcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgYXV0byBiaW5kaW5nIG9mIHJlcXVlc3QgdmFsdWVzIHRvIHB1YmxpYyBQYWdlIGZpZWxkcy4gU2VlIHRoZSBDbGlja1NlcnZsZXQgbWV0aG9kIA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNwcm9jZXNzUGFnZVJlcXVlc3RQYXJhbXMob3JnLmFwYWNoZS5jbGljay5QYWdlLCBqYXZheC5zZXJ2bGV0Lmh0dHAuSHR0cFNlcnZsZXRSZXF1ZXN0KSI+cHJvY2Vzc1BhZ2VSZXF1ZXN0UGFyYW1zKCk8L2E+DQogICAgICAgIGZvciBkZXRhaWxzLiBUaGlzIGFkZGl0aW9uIHdhcyByYWlzZWQgYnkgU3RlcGhlbiBIYWJlcm1hbi4gDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBGb3JtDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2NsZWFyVmFsdWVzKCkiPmNsZWFyVmFsdWVzKCk8L2E+IA0KICAgICAgICBtZXRob2QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBDbGlja1V0aWxzIA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCNnZXRNaW1lVHlwZShqYXZhLmxhbmcuU3RyaW5nKSI+Z2V0TWltZVR5cGUoKTwvYT4gDQogICAgICAgIG1ldGhvZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG92ZXJyaWRpbmcgQ2xpY2sgQXBwbGljYXRpb24gbW9kZSBieSBkZWZpbmluZyBhIFN5c3RlbSBwcm9wZXJ0eSA8dHQ+Y2xpY2subW9kZTwvdHQ+LiANCiAgICAgICAgRm9yIGV4YW1wbGU6IDx0dD4tRGNsaWNrLm1vZGU9dHJhY2U8L3R0Pg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCBUYWJsZSBwYWdpbmcgYWNyb3NzIHZlcnkgbGFyZ2UgbGlzdHMuDQogICAgICA8L2xpPiAgICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJSW1wcm92ZWQgVGFibGUgcmVuZGVyaW5nIHBlcmZvcm1hbmNlLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEzNiI+MTM2PC9hPl0uDQogICAgICA8L2xpPiAgICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUltcHJvdmVkIE9HTkwgZm9ybSBiaW5kaW5nIHBlcmZvcm1hbmNlLg0KICAgICAgPC9saT4gICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIENsaWNrIGNvbmZpZ3VyYXRpb24gZGVmYXVsdHM6DQogICAgICAgIDx1bCBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5wYWdlIGF1dG9tYXBwaW5nIGlzIGVuYWJsZWQgYnkgZGVmYXVsdDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPmdsb2JhbCBubyBjYWNoZSBoZWFkZXJzIGFyZSB1c2VkIGlmIG5vIGhlYWRlcnMgZGVmaW5lZDwvbGk+DQogICAgICAgIDwvdWw+DQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCVVwZGF0ZWQgQ2xpY2tTZXJ2bGV0IHRvIHVzZSByZXNwb25zZSBXcml0ZXIgdG8gc3VwcG9ydCB0aGUgDQogICAgICAJPGEgaHJlZj0iaHR0cDovL21lc3NhZG1pbi5zb3VyY2Vmb3JnZS5uZXQvIj5NZXNzQWRtaW48L2E+IHNlc3Npb24gbW9uaXRvcmluZyB0b29sLg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgU3ZlbiBIZXJzY2hlbCBhbmQgYSBwYXRjaCB3YXMgcHJvdmlkZWQgYnkNCiAgICAgIAlCb2IgU2NoZWxsaW5rDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTQ2Ij4xNDY8L2E+XS4NCiAgICAgIDwvbGk+ICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIE5QRSBpbiBQcm9wZXJ0eVNlbGVjdCB3aGVuIGxhYmVsIGlzIG51bGwuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEYXZpZCBGcml6ZWxsZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEzMiI+MTMyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIE9nbmxFeGNlcHRpb24gaW4gQ29sdW1uIHdoZW4gZXZhbHVhdGluZyBudWxsIHByb3BlcnR5IHBhdGhzLiANCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMzMiPjEzMzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBPZ25sIE51bGwgcHJvcGVydHkgZXZhbHVhdGlvbiBidWcgd2hlbiBoYW5kbGluZyBEYXRlIHByb3BlcnRpZXMuIA0KICAgICAgCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEYXZpZCBGcml6ZWxsZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEzNyI+MTM3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIEpTUCBwYWdlIGF1dG9tYXBwaW5nIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluaw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE0MiI+MTQyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIEhpYmVybmF0ZUZvcm0gbm90IHdvcmtpbmcgZm9yIENHTGliIHByb3hpZXMuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgDQogICAgICAJYW5kIGZpeGVkIGJ5IENhcm9saW5lIEJyaWZmYSANCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNDQiPjE0NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBDYXllbm5lRm9ybSBidWcgd2hlcmUgRk9JRCB3YXMgbm90IGJlaW5nIHVwZGF0ZWQgZm9yIHJlY2VudGx5IGNvbW1pdHRlZCBEYXRhT2JqZWN0LiANCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNDUiPjE0NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgZGVwZW5kZW5jeSBvbiBEb3VnaCBMZWEncyBDb25jdXJyZW50IFV0aWxpdGllcyBsaWJyYXJ5IHZlcnNpb24gMS4zLjQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGUgVmVsb2NpdHkgMS41LWRldiBsaWJyYXJ5IHRvIFNWTiByZXZpc2lvbiA0NjcxNzkuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIE9HTkwgbGlicmFyeSB0byB2ZXJzaW9uIDIuNi45Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy4gQ2xpY2sgUXVpY2tzdGFydCBoYXMgYWxzbyBiZWVuIGFkZGVkIA0KICAgICAgICBhcyBhbiBleGFtcGxlIGFwcGxpY2F0aW9uLg0KICAgICAgPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjAgLSAzcmQgT2N0b2JlciAyMDA2PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iY2xpY2stY2hlYXQtc2hlZXQucGRmIj5DaGVhdCBTaGVldDwvYT4gZ3VpZGUuDQogICAgICAJVGhpcyBmZWF0dXJlIHdhcyByYWlzZWQgYnkgQWhtZWQgTW9ob21iZSBhbmQgUmljYXJkbyBMZWNoZXRhLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBDb2x1bW4gPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Db2x1bW4uaHRtbCNtYXhMZW5ndGgiPm1heExlbmd0aDwvYT4gcHJvcGVydHkNCiAgICAgIAl0byBsaW1pdCB0aGUgbnVtYmVyIGNoYXJhY3RlcnMgZGlzcGxheWVkLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBOUEUgaW4gVGFibGUgQWN0aW9uTGluayBwYWdpbmF0aW9uLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUmljYXJkbyBMZWNoZXRhDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTI0Ij4xMjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgY3VzdG9tIEVycm9yUGFnZSBub3QgcmVzb2x2aW5nLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgR2xlbiBTdGFtcG91bHR6aXMNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMjYiPjEyNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBOdW1iZXJGb3JtYXRFeGNlcHRpb24gaW4gTGlua0RlY29yYXRvcg0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTI3Ij4xMjc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgTnVtYmVyRm9ybWF0RXhjZXB0aW9uIHdoZW4gdXNpbmcgRm9ybS5vblN1Ym1pdENoZWNrKCkgd2l0aCBhIEZpbGVGaWVsZC4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IFNhdG9zaGkgVGFrYXRhDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMjciPjEyODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBDYXllbm5lRm9ybSBidWcgd2l0aCByZXF1aXJlZCBwcm9wZXJ0eSBzZXQgb24gQ2hlY2tib3guDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBEYXZpZCBGcml6ZWxsZQ0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTI5Ij4xMjk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgUHJvcGVydHlTZWxlY3QgYnVnIHdoZXJlIGZpcnN0IGl0ZW0gZGlzcGxheXMgdHdpY2UgdW5kZXIgY2VydGFpbiBjb25kaXRpb25zLg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEzMCI+MTMwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCVVwZGF0ZWQgYW5kIHZlcmlmaWVkIENsaWNrIEZyYW1ld29yayBhbmQgRXh0cmFzIGNvZGViYXNlIGFnYWluc3QgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHA6Ly9maW5kYnVncy5zb3VyY2Vmb3JnZS5uZXQvaW5kZXguaHRtbCI+RmluZEJ1Z3M8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBDYXllbm5lIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjIuMS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDEuMCBSQzIgLSA2dGggU2VwdGVtYmVyIDIwMDY8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0ZsYXNoQXR0cmlidXRlLmh0bWwiPkZsYXNoQXR0cmlidXRlPC9hPg0KICAgICAgICBjbGFzcyBwcm92aWRpbmcgZmxhc2ggc2NvcGUgc2Vzc2lvbiBhdHRyaWJ1dGVzLiBPbmNlIGEgZmxhc2ggYXR0cmlidXRlIA0KICAgICAgICBoYXMgYmVlbiBhY2Nlc3NlZCBmcm9tIHRoZSBzZXNzaW9uIGl0IGlzIHJlbW92ZWQuIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0xpbmtEZWNvcmF0b3IuaHRtbCI+TGlua0RlY29yYXRvcjwvYT4NCiAgICAgICAgY2xhc3MgZm9yIHJlbmRlcmluZyBhY3Rpb24gbGlua3MgaW4gY29sdW1uIHRhYmxlcy4gVGhpcyBjbGFzcyB3YXMgaW5zcGlyZWQgDQogICAgICAgIGJ5IFJpY2hhcmRvIExlY2hldGEncyA8dHQ+Vmlld0RlY29yYXRvcjwvdHQ+IHBhdHRlcm4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBwYWdpbmcgc3VwcG9ydCB0byANCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0Zvcm1UYWJsZS5odG1sIj5Gb3JtVGFibGU8L2E+IA0KICAgICAgICBjb250cm9sLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwiPkZvcm08L2E+DQogICAgICAgIHN0YXJ0VGFnKCkgYW5kIGVuZFRhZygpIG1ldGhvZHMgdG8gc3VwcG9ydCBsYXlpbmcgb3V0IGZvcm1zIG1hbnVhbGx5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgRm9ybQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNjbGVhckVycm9ycygpIj5jbGVhckVycm9ycygpPC9hPiANCiAgICAgICAgbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgUGFnZSB0ZW1wbGF0aW5nIHN1cHBvcnQgZm9yIEpTUCBwYWdlcy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2UgYnkgSHV5IERvLiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIFRhaXdhbiBwcm9wZXJ0aWVzIGZpbGUgcHJvdmlkZWQgYnkgSHVhbmcuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBuZXcgQ2xpY2sgTG9nbyBwcm92aWRlZCBieSBBaG1lZCBNb2hvbWJlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgRm9ybSBjbGllbnQgc2lkZSBKYXZhU2NyaXB0IHZhbGlkYXRpb24gcHJvdmlkZWQgYnkgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTExNSI+MTE1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCVVwZGF0ZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Db2x1bW4uaHRtbCI+Q29sdW1uPC9hPg0KICAgICAgICBjbGFzcyB0byBlc2NhcGUgSFRNTCBjaGFyYWN0ZXJzIGJ5IGRlZmF1bHQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSANCiAgICAgICAgR2xlbiBTdGFtcG91bHR6aXMgDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTE4Ij4xMTg8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0h0bWxTdHJpbmdCdWZmZXIuaHRtbCI+SHRtbFN0cmluZ0J1ZmZlcjwvYT4NCiAgICAgICAgdG8gaW1wcm92ZSBIVE1MIGNoYXJhY3RlciBlc2NhcGluZyBwZXJmb3JtYW5jZSwgcmVtb3ZpbmcgQXBhY2hlIENvbW1vbnMgTGFuZydzIHVzZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL2Zpc2hleWUzLmNlbnF1YS5jb20vYnJvd3NlL2NsaWNrLyI+RmlzaEV5ZTwvYT4gcHJvamVjdCB2aWV3IA0KICAgICAgICBwcm92aWRlZCBieSA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vd3d3LmNlbnF1YS5jb20iPkNlbnF1YTwvYT4uICAgICAgDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDEuMi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgSGliZXJuYXRlIGxpYnJhcnkgdG8gdmVyc2lvbiAzLjEuMy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9maWx0ZXIvQ29tcHJlc3Npb25GaWx0ZXIuaHRtbCI+Q29tcHJlc3Npb25GaWx0ZXI8L2E+DQogICAgICAgIHRvIGNvbXByZXNzIHJlc3BvbnNlIGJ5IGRlZmF1bHQgYW5kIHRvIGF1dG9tYXRpY2FsbHkgc2V0IGFueSBjb25maWd1cmVkIENsaWNrIGNoYXJzZXQuIA0KICAgICAgICBUaGVzZSBpc3N1ZXMgd2VyZSByYWlzZWQgYnkgUmljYXJkbyBMZWNoZXRhIGFuZCBOYW9raSBUYWtlem9lDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTE5Ij4xMTk8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIE5QRSBpbiBEYXRlRmllbGQgd2hlbiBzZXR0aW5nIHZhbHVlIHRvIG51bGwuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBHZW9mZiBIb3Bzb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMjEiPjEyMTwvYT5dLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDEuMCBSQzEgLSAzMXRoIEp1bHkgMjAwNjwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9Gb3JtVGFibGUuaHRtbCI+Rm9ybVRhYmxlPC9hPg0KICAgICAgICBkYXRhIGdyaWQgY29udHJvbCBhbmQgYXNzb2NpYXRlZCANCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0ZpZWxkQ29sdW1uLmh0bWwiPkZpZWxkQ29sdW1uPC9hPg0KICAgICAgICBjbGFzcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9QYWdlU3VibWl0Lmh0bWwiPlBhZ2VTdWJtaXQ8L2E+DQogICAgICAgIGNvbnRyb2wgZm9yIHJlZGlyZWN0aW5nIHRvIHRhcmdldCBwYWdlcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgUGFnZQ0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzZXRGb3J3YXJkKGphdmEubGFuZy5DbGFzcykiPnNldEZvcndhcmQoQ2xhc3MpPC9hPiBtZXRob2QuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCANCiAgICAgICA8YSBocmVmPSJxdWljay1zdGFydC5odG1sIj5RdWljayBTdGFydDwvYT4gdG9waWMgdG8gQ2xpY2sgZG9jdW1lbnRhdGlvbi4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBNb2RpZmllZCBGb3JtDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2lzRm9ybVN1Ym1pc3Npb24oKSI+aXNGb3JtU3VibWlzc2lvbigpPC9hPg0KICAgICAgICBtZXRob2QgdG8gb25seSByZXR1cm4gdHJ1ZSBpZiB0aGUgc3VibWlzc2lvbiBpcyBmcm9tIHRoaXMgZm9ybS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMjEgLSAxOXRoIEp1bHkgMjAwNjwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MC41ZW07Ij4gDQogICAgRmluYWwgbmV3IGZlYXR1cmVzIHJlbGVhc2UgZm9yIENsaWNrIDEuMC48L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgUGFnZSANCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjb25SZW5kZXIoKSI+b25SZW5kZXIoKTwvYT4NCiAgICAgICBtZXRob2QuIFRoaXMgYWRkaXRpb24gd2FzIHJhaXNlZCBieSBTdGVwaGVuIEhhYmVybWFuDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMDUiPjEwNTwvYT5dLg0KICAgICAgPC9saT4gICAgICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEF1dG8gYWRkIHB1YmxpYyBQYWdlIGZpZWxkcyB0byB0aGUgbW9kZWwuIA0KICAgICAgIFNlZSB0aGUgQ2xpY2tTZXJ2bGV0IG1ldGhvZHMNCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNpbml0UGFnZShqYXZhLmxhbmcuU3RyaW5nLCBqYXZhLmxhbmcuQ2xhc3MsIGphdmF4LnNlcnZsZXQuaHR0cC5IdHRwU2VydmxldFJlcXVlc3QpIj5pbml0UGFnZSgpPC9hPg0KICAgICAgIGFuZCANCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNjcmVhdGVWZWxvY2l0eUNvbnRleHQob3JnLmFwYWNoZS5jbGljay5QYWdlKSI+Y3JlYXRlVmVsb2NpdHlDb250ZXh0KCk8L2E+DQogICAgICAgZm9yIGRldGFpbHMuIFRoaXMgYWRkaXRpb24gd2FzIHJhaXNlZCBieSBTdGVwaGVuIEhhYmVybWFuDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMDkiPjEwOTwvYT4sDQogICAgICAgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTExMiI+MTEyPC9hPl0uDQogICAgICA8L2xpPiAgICAgICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgUmVmYWN0b3JlZCBwYW5lbCBwYWNrYWdlIHdpdGggQmFzaWNQYW5lbCByZW5hbWVkIA0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvUGFuZWwuaHRtbCI+UGFuZWw8L2E+IGFuZCBtb3ZlZA0KICAgICAgIGludG8gdGhlIGNvcmUgY29udHJvbCBwYWNrYWdlLCBhbmQgcmVtb3ZpbmcgdGhlIFBhbmVsIGludGVyZmFjZS4NCiAgICAgICBUaGUgDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9wYW5lbC9MaXN0UGFuZWwuaHRtbCI+TGlzdFBhbmVsPC9hPg0KICAgICAgIGFuZCAgDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9wYW5lbC9UYWJiZWRQYW5lbC5odG1sIj5UYWJiZWRQYW5lbDwvYT4NCiAgICAgICBjbGFzc2VzIGhhdmUgYmVlbiByZXZpc2VkIHRvIHRha2UgYWR2YW50YWdlIG9mIHRoZSBuZXcgUGFuZWwgY2FwYWJpbGl0aWVzLg0KICAgICAgIDxwLz4NCiAgICAgICBQYW5lbHMgYXJlIG5vdyByZW5kZXJlZCBhcyA8dHQ+JHBhbmVsPC90dD4gcmF0aGVyIHRoYW4gPHR0PiNwYXJzZSgkcGFuZWwpPC90dD4gDQogICAgICAgPHAvPiAgICAgICANCiAgICAgICBQYW5lbHMgY2FuIG5vdyBkZWZpbmUgVmVsb2NpdHkgdGVtcGxhdGVzIG9uIHRoZSBjbGFzc3BhdGggYXMgd2VsbCBhcyB0aGUgd2ViIGZpbGUgc3lzdGVtLg0KICAgICAgPC9saT4gICAgICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIA0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvUGFnZUxpbmsuaHRtbCI+UGFnZUxpbms8L2E+DQogICAgICAgY29udHJvbC4gVGhpcyBhZGRpdGlvbiB3YXMgcmFpc2VkIGJ5IFN0ZXBoZW4gSGFiZXJtYW4NCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEwNiI+MTA2PC9hPl0uDQogICAgICA8L2xpPiAgICAgICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgT0dOTCBzdXBwb3J0IGZvciByZW5kZXJpbmcgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Db2x1bW4uaHRtbCI+Q29sdW1uPC9hPg0KICAgICAgIHZhbHVlcy4NCiAgICAgIDwvbGk+ICAgICAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBtdWx0aXBsZSBBY3Rpb25MaW5rIHBhcmFtZXRlcnMsIHNlZSANCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0TGluay5odG1sI3NldFBhcmFtZXRlcihqYXZhLmxhbmcuU3RyaW5nLCBqYXZhLmxhbmcuU3RyaW5nKSI+c2V0UGFyYW1ldGVyKCk8L2E+DQogICAgICAgZm9yIGRldGFpbHMuDQogICAgICA8L2xpPiAgICAgICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgTWVudSANCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTWVudS5odG1sI2lzVXNlckluUm9sZXMoKSI+aXNVc2VySW5Sb2xlcygpPC9hPg0KICAgICAgIG1ldGhvZC4NCiAgICAgIDwvbGk+ICAgICAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCANCiAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNS5odG1sIj5CZXN0IFByYWN0aWNlczwvYT4gdG9waWMgdG8gQ2xpY2sNCiAgICAgICBkb2N1bWVudGF0aW9uLg0KICAgICAgPC9saT4gICAgICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIFRvbWNhdCBkZXBsb3ltZW50IGlzc3VlIHdoZXJlIFRvbWNhdCBDbGFzc0xvYWRlciB3YXMgbG9ja2luZyBDbGljaw0KICAgICAgIEpBUnMgcHJldmVudGluZyBhcHBsaWNhdGlvbiByZWRlcGxveW1lbnQuIER1ZSBsb2NraW5nIG9uIFVSTCBzdHJlYW1zLA0KICAgICAgIHRoZSBkZXBsb3ltZW50IHRlY2huaXF1ZSBoYXMgcmV2ZXJ0ZWQgYmFjayB0byB1c2luZyB1bmlxdWVseSBuYW1lZCBmaWxlcyAocHJlIDAuMTkpLg0KICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEb3ljaGkNCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTgyIj44MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBGaXhlZCBNZXNzYWdlc01hcCBjYWNoZSBwZXJtaXNzaW9ucyBpc3N1ZS4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBEYXZpZCBGZWxpcw0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstOTkiPjk5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIEZpZWxkIHNldEZvY3VzKCkgYnVnLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IERhdmlkIEZlbGlzDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMDIiPjEwMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBGaXhlZCBDb250ZXh0IHNlc3Npb24gTG9jYWxlIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBTdGV2ZW4gVmFuIEhvb2YNCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEwNyI+MTA3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIFNlbGVjdCB2YWxpZGF0aW9uIGJ1ZyB3aGVuIG5vIG9wdGlvbnMgYXJlIGRlZmluZWQuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTExMCI+MTEwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIERvdWJsZUZpZWxkIHZhbGlkYXRpb24gYnVnIHdpdGggIjAiIHZhbHVlLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMTEiPjExMTwvYT5dLg0KICAgICAgPC9saT4gICAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBNb3ZlZCBBY3Rpb25CdXR0b24gY29udHJvbCBmcm9tIENsaWNrIEV4dHJhcyB0byBjb3JlIGNvbnRyb2xzIHBhY2thZ2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIFJlbW92ZWQgZGVwcmVjaWF0ZWQgQ29udGV4dCBzZXNzaW9uT2JqZWN0IG1ldGhvZHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjIwIC0gN3RoIEp1bmUgMjAwNjwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgY2xpZW50IHNpZGUgSmF2YVNjcmlwdA0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2Zvcm0tdmFsaWRhdGlvbiI+Rm9ybSBWYWxpZGF0aW9uPC9hPg0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTYiPjE2PC9hPl0uDQogICAgICA8L2xpPiAgICAgICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgbmV3IENsaWNrIGV4dHJhcyBjb250cm9scw0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9DaGVja0xpc3QuaHRtbCI+Q2hlY2tMaXN0PC9hPiBhbmQNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvQ29sb3JQaWNrZXIuaHRtbCI+Q29sb3JQaWNrZXI8L2E+Lg0KICAgICAgIFRoZXNlIGNvbnRyb2xzIHdlcmUgYWRkZWQgYnkgQ2hyaXN0aWFuIEVzc2VsDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy04MSI+ODE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBhIGdsb2JhbCBwYWdlIG1lc3NhZ2UgYnVuZGxlLCBzZWUgUGFnZSANCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjZ2V0TWVzc2FnZShqYXZhLmxhbmcuU3RyaW5nKSI+Z2V0TWVzc2FnZSgpPC9hPg0KICAgICAgIGZvciBkZXRhaWxzLiBUaGlzIGlzc3VlIHJhaXNlZCBieSBDbGF1ZGlvIFJvc3NldHRvIA0KICAgICAgIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MiI+NzI8L2E+XS4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwiPkNvbnRyb2w8L2E+DQogICAgICAgPHR0PnBhcmVudDwvdHQ+IHByb3BlcnR5IA0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstODgiPjg4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIHN1cHBvcnQgdGFibGUgQ29sdW1uIHN1cHBvcnQgZm9yIDx0dD5qYXZhLnV0aWwuTWFwPC90dD4gcm93IG9iamVjdHMuDQogICAgICAgVGhpcyBpc3N1ZSByYWlzZWQgYnkgSi5GLiBaYXJhbWEgIA0KICAgICAgIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy05MSI+OTE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgb3B0aW9uIHRvIHBsYWNlIFRhYmxlIGJhbm5lciBvbiB0b3AuIA0KICAgICAgIFNlZSBUYWJsZQ0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCNiYW5uZXJQb3NpdGlvbiI+YmFubmVyUG9zaXRpb248L2E+DQogICAgICAgSmF2YWRvYyBmb3IgZGV0YWlscy4gVGhpcyBpc3N1ZSByYWlzZWQgYnkgSi5GLiBaYXJhbWEgIA0KICAgICAgIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy05MiI+OTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkIGNvbmZpZ3VyYWJsZSBhcHBsaWNhdGlvbiBMb2NhbGUuIFNlZSANCiAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2NsaWNrLWFwcCI+Q2xpY2sgQXBwPC9hPiBmb3INCiAgICAgICBkZXRhaWxzIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy05NiI+OTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgJ1BhZ2UnIHN1ZmZpeCB3aGVuIGF1dG9tYXBwaW5nIHBhdGggLT4gY2xhc3NuYW1lLg0KICAgICAgIFNlZSA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2FwcGxpY2F0aW9uLWF1dG9tYXBwaW5nIj5hdXRvbWFwcGluZzwvYT4NCiAgICAgICB0b3BpYyBmb3IgZGV0YWlscy4gVGhpcyBpc3N1ZSByYWlzZWQgYnkgU3RlcGhlbiBIYWJlcm1hbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgUGFnZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0UmVkaXJlY3QoamF2YS5sYW5nLkNsYXNzKSI+c2V0UmVkaXJlY3QocGFnZUNsYXNzKTwvYT4NCiAgICAgICBtZXRob2QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIEZvcm1hdCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0Zvcm1hdC5odG1sI2N1cnJlbnREYXRlKCkiPmN1cnJlbnREYXRlKCk8L2E+DQogICAgICAgbWV0aG9kcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgcmVxdWVzdCBwYXJhbWV0ZXIgdG8gQ2xpY2tTZXJ2bGV0ICAgDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ2xpY2tTZXJ2bGV0Lmh0bWwjbmV3UGFnZUluc3RhbmNlKGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5DbGFzcywgamF2YXguc2VydmxldC5odHRwLkh0dHBTZXJ2bGV0UmVxdWVzdCkiPm5ld1BhZ2VJbnN0YW5jZSgpPC9hPg0KICAgICAgIG1ldGhvZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgQnJhemlsaWFuIHByb3BlcnRpZXMgZmlsZXMgcHJvdmlkZWQgYnkgDQogICAgICAgUmljYXJkbyBMZWNoZXRhIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy04NiI+ODY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgPGEgdGFyZ2V0PSJibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2F5ZW5uZS5hcGFjaGUub3JnLyI+Q2F5ZW5uZTwvYT4NCiAgICAgICBpbnRlZ3JhdGlvbiBleGFtcGxlIHRvIEV4YW1wbGVzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCA8YSB0YXJnZXQ9ImJsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly93d3cuc3ByaW5nc291cmNlLm9yZy8iPlNwcmluZzwvYT4NCiAgICAgICBpbnRlZ3JhdGlvbiBleGFtcGxlIHRvIEV4YW1wbGVzIGFuZCBpbXByb3ZlZCANCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NwcmluZy9TcHJpbmdDbGlja1NlcnZsZXQuaHRtbCI+U3ByaW5nQ2xpY2tTZXJ2bGV0PC9hPg0KICAgICAgIGRvY3VtZW50YXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEltcHJvdmVkIFZlbG9jaXR5IHJlbmRlcmluZyBwZXJmb3JtYW5jZS4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBhbmQgDQogICAgICAgZml4ZWQgYnkgU3RlcGhlbiBIYWJlcm1hbiANCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9J2h0dHA6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9WRUxPQ0lUWS00MzgnPlZFTE9DSVRZLTQzODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBJbXByb3ZlZCAgICANCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0h0bWxTdHJpbmdCdWZmZXIuaHRtbCI+SHRtbFN0cmluZ0J1ZmZlcjwvYT4NCiAgICAgICBwZXJmb3JtYW5jZSB3aXRoIHVuc3luY2hyb25pemVkIGFwcGVuZCBtZXRob2RzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBJbXByb3ZlZCBDU1MgbGluayByZW5kZXJpbmcgdG8gZW5hYmxlIGFsdGVybmF0ZSBzdHlsZSBzaGVldHMuIFRoaXMNCiAgICAgICBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEVucmljbyBEb25lbGxpDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy04MSI+ODE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgRml4ZWQgPHR0PlVuc3VwcG9ydGVkRW5jb2RpbmdFeGNlcHRpb248L3R0PiBpbiBDbGlja1V0aWxzLmVuY29kZVVybCgpIHdoZW4NCiAgICAgICBhcHBsaWNhdGlvbiBjaGFyc2V0IGlzIHVuZGVmaW5lZA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTg3Ij44NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBGaXhlZCBmaWxlIGRlcGxveW1lbnQgaXNzdWUgb24gc2VydmVycyB3aXRoIHJlc3RyaWN0ZWQgcGVybWlzc2lvbnMuDQogICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZlbGlzDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy05NSI+OTU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgUmVtb3ZlZCBDb250cm9sIDx0dD5wYXJlbnRNZXNzYWdlczwvdHQ+IHByb3BlcnR5IHdoaWNoIHdhcyBlZmZlY3RpdmVseQ0KICAgICAgIHJlcGxhY2VkIGJ5IG5ldyA8dHQ+cGFyZW50PC90dD4gYW5kIDx0dD5tZXNzYWdlczwvdHQ+IHByb3BlcnRpZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIFJlbW92ZWQgRm9ybSBzdXBwb3J0IGZvciBTdHJ1dHMgc3R5bGUgZXJyb3IgbWVzc2FnZSByZW5kZXJpbmcuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIFVwZGF0ZWQgVmVsb2NpdHkgMS41LWRldiBKQVIgc25hcHNob3QgdG8gcmV2aXNpb24gMzkwNzM1LCB3aXRoDQogICAgICAgcGF0Y2ggVkVMT0NJVFktNDM4IGFwcGxpZWQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIFVwZGF0ZWQgcGFja2FnaW5nOiA8dHQ+Y2xpY2stZG9jdW1lbnRhdGlvbi53YXI8L3R0PiByZXBsYWNlZCBieSANCiAgICAgICAgPHR0PmRvY3VtZW50YXRpb248L3R0PiBkaXJlY3RvcnkgYW5kIDx0dD53ZWJhcHBzL2NsaWNrLWV4YW1wbGVzPC90dD4NCiAgICAgICAgbW92ZWQgdG8gPHR0PmV4YW1wbGVzPC90dD4gZGlyZWN0b3J5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4xOSAtIDh0aCBBcHJpbCAyMDA2PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbTowLjVlbTsiPiBOZXcgZGV2ZWxvcGVyDQogICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9jaHJpc2ljaHJpcy8iPkNocmlzdGlhbiBFc3NsPC9hPg0KICAgIGpvaW5zIHRoZSBDbGljayBwcm9qZWN0LjwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBOZXcgPGEgaHJlZj0iaHR0cDovL3d3dy5zdW52b2x0LmNvbS9jb25mbHVlbmNlL2Rpc3BsYXkvQ0xLVC9DbGlja0lERSI+Q2xpY2tJREU8L2E+IA0KICAgICAgIEVjbGlwc2UgV1RQIHBsdWctaW4gcmVsZWFzZWQgYnkgTmFva2kgVGFrZXpvZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgbmV3IENsaWNrIEV4dHJhcyBjb250cm9scyANCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0FjdGlvbkJ1dHRvbi5odG1sIj5BY3Rpb25CdXR0b248L2E+LA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9Mb25nRmllbGQuaHRtbCI+TG9uZ0ZpZWxkPC9hPiwNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTnVtYmVyRmllbGQuaHRtbCI+TnVtYmVyRmllbGQ8L2E+LA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9UYWJiZWRGb3JtLmh0bWwiPlRhYmJlZEZvcm08L2E+IGFuZA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9UZWxlcGhvbmVGaWVsZC5odG1sIj5UZWxlcGhvbmVGaWVsZDwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIG5ldyBDbGljayBFeHRyYXMgQ2F5ZW5uZSBjb250cm9scyANCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvUHJvcGVydHlTZWxlY3QuaHRtbCI+UHJvcGVydHlTZWxlY3Q8L2E+LA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9RdWVyeVNlbGVjdC5odG1sIj5RdWVyeVNlbGVjdDwvYT4gYW5kDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL1RhYmJlZENheWVubmVGb3JtLmh0bWwiPlRhYmJlZENheWVubmVGb3JtPC9hPi4NCiAgICAgICBBbHNvIGFkZGVkIHdlYiANCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvRGF0YUNvbnRleHRGaWx0ZXIuaHRtbCI+RGF0YUNvbnRleHRGaWx0ZXI8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgQ29udGV4dCBwYWdlIHBhdGggbG9va3VwIG1ldGhvZCANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI2dldFBhZ2VQYXRoKGphdmEubGFuZy5DbGFzcykiPmdldFBhZ2VQYXRoKCk8L2E+Lg0KICAgICAgICBUaGlzIGZlYXR1cmUgd2FzIHN1Z2dlc3RlZCBieSBDaHJpc3RpYW4gRXNzbA0KICAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjgiPjY4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjZGF0YS1iaW5kaW5nIj5kYXRhIGJpbmRpbmc8L2E+DQogICAgICAgIG9mIG5lc3RlZCBvYmplY3RzIGluIGZvcm0gZmllbGRzIHVzaW5nIA0KICAgICAgICA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vd3d3Lm9nbmwub3JnIj5PR05MPC9hPiBsaWJyYXJ5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgRm9ybSBidXR0b25TdHlsZSwgZmllbGRTdHlsZSBhbmQgbGFiZWxTdHlsZSBhdHRyaWJ1dGVzIHRvIHN1cHBvcnQNCiAgICAgICAgY3VzdG9taXNlZCBmb3JtDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2F1dG8tbGF5b3V0Ij5hdXRvIGxheW91dHM8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgQ29udHJvbCBWZWxvY2l0eSB0ZW1wbGF0ZXMgdXNpbmcgbmV3IENvbnRleHQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI3JlbmRlclRlbXBsYXRlKGphdmEubGFuZy5DbGFzcywgamF2YS51dGlsLk1hcCkiPnJlbmRlclRlbXBsYXRlKCk8L2E+DQogICAgICAgIG1ldGhvZHMuIFNlZSBDbGljayBFeGFtcGxlcyAnUmljaCBUZXh0IEFyZWEnIGFuZCAnVGFiYmVkIEZvcm0nIGZvciANCiAgICAgICAgZGVtb25zdHJhdGlvbnMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBwYWdlIGF1dG9tYXBwaW5nDQogICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAyLmh0bWwjYXBwbGljYXRpb24tZXhjbHVkZXMiPmV4Y2x1ZGVzPC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBBaG1lZCBNb2hvbWJlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTIiPjUyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBUYWJsZSBjb250cm9sIG1vdXNlb3ZlciByb3cgaGlnaGxpZ2h0Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IEFobWVkIE1vaG9tYmUgYW5kIHJlc29sdmVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTciPjU3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXM9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgRnJlbmNoIGFuZCBJdGFsaWFuIHByb3BlcnRpZXMgZmlsZXMgcHJvdmlkZWQgYnkgDQogICAgICAgTG9yZW56byBPcnNlbGxpIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NSI+NjU8L2E+LA0KICAgICAgIDxhIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY2Ij42NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvc3ByaW5nL1NwcmluZ0NsaWNrU2VydmxldC5odG1sIj5TcHJpbmdDbGlja1NlcnZsZXQ8L2E+DQogICAgICAgIGNvbmZpZ3VyYXRpb24gb3B0aW9ucyBhbmQgZG9jdW1lbnRhdGlvbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvRm9ybWF0Lmh0bWwiPkZvcm1hdDwvYT4gDQogICAgICAgIGNsYXNzIG5vdyB1c2VzIHJlcXVlc3QgY29udGV4dCBMb2NhbGUuIA0KICAgICAgICBQbGVhc2Ugbm90ZSB0aGlzIGNoYW5nZSByZXF1aXJlcyBtb2RpZmljYXRpb24gdG8gRm9ybWF0IHN1YmNsYXNzDQogICAgICAgIGNvbnN0cnVjdG9ycy4gICAgICAgIA0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQ2hyaXN0aWFuIEVzc2wNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03OSI+Nzk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgVmVsb2NpdHkgbGlicmFyeSB0byBsYXRlc3QgMS41LWRldiBidWlsZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQ2F5ZW5uZSBsaWJyYXJ5IHRvIHZlcnNpb24gMS4yQjEuDQogICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL0NheWVubmVGb3JtLmh0bWwiPkNheWVubmVGb3JtPC9hPiANCiAgICAgICAgZHVwbGljYXRlIGluc2VydCBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkNCiAgICAgICAgQm9iIFNjaGVsbGluayBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjMiPjYzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXM9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIERhdGVGaWVsZCBpbnRlcm5hdGlvbmFsaXp0aW9uIGJ1Zy4gSXNzdWUgaWRlbnRpZmllZCBieSANCiAgICAgICAgTG9yZW56byBPcnNlbGxpIGFuZCBmaXggcHJvdmlkZWQgYnkgIE5hb2tpIFRha2V6b2UNCiAgICAgICAgWzxhIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYwIj42MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDbGlja1V0aWxzIGludm9rZUxpc3RlbmVyIG9uIGFub255b3Vtb3VzIGlubmVyIGNsYXNzZXMgYnVnLg0KICAgICAgICBUaGlzIGlzc3VlIGlkZW50aWZpZWQgYW5kIGZpeGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03NyI+Nzc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEFjdGlvbkxpbmsgcGFyYW1ldGVyIGVuY29kaW5nIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbmRpZmllZCBieQ0KICAgICAgICBTdGV2ZW4gVmFuIEhvb2YgYW5kIGZpeGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzgiPjc4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZW1vdmVkIGV4YW1wbGUgPHR0PmNsaWNrLWJsYW5rPC90dD4gYW5kIDx0dD5jbGljay1jYXllbm5lPC90dD4gYXBwbGljYXRpb25zDQogICAgICAgIGZyb20gbWFpbiBkaXN0cmlidXRpb24uIFRoZXNlIGV4YW1wbGVzIHdpbGwgYmUgcmVsZWFzZWQgYXMgc2VwYXJhdGUgDQogICAgICAgIHBhY2thZ2VzIHVuZGVyIHNvdXJjZWZvcmdlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4xOCAtIDE1dGggSmFudWFyeSAyMDA2PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbTowLjVlbTsiPiBOZXcgZGV2ZWxvcGVyDQogICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy90YWtlem9lLyI+TmFva2kgVGFrZXpvZTwvYT4NCiAgICBqb2lucyB0aGUgQ2xpY2sgcHJvamVjdC48L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIENyZWF0ZWQgbmV3IHBhY2thZ2UgDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9wYWNrYWdlLXN1bW1hcnkuaHRtbCI+b3JnLmFwYWNoZS5jbGljay5leHRyYXMuY29udHJvbDwvYT4NCiAgICAgICAgZm9yIGV4dGVuZGVkIEhUTUwgY29udHJvbHMuIFRoZSBmb2xsb3dpbmcgY29udHJvbHMgaGF2ZSBiZWVuIG1vdmVkDQogICAgICAgIGludG8gdGhpcyBwYWNrYWdlOiBDcmVkaXRDYXJkRmllbGQsIERhdGVGaWVsZCwgRG91YmxlRmllbGQsIEVtYWlsRmllbGQsDQogICAgICAgIEludGVnZXJGaWVsZCBhbmQgTWVudS4NCiAgICAgICAgPHAvPg0KICAgICAgICBUYWJsZSBjb250cm9sIHByb21vdGVkIHRvIGNvcmUgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9wYWNrYWdlLXN1bW1hcnkuaHRtbCI+b3JnLmFwYWNoZS5jbGljay5jb250cm9sPC9hPi4NCiAgICAgICAgPHAvPg0KICAgICAgICBBZGRlZCBDb250cm9sIG1ldGhvZHMgDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNnZXRIdG1sSW1wb3J0cygpIj5nZXRIdG1sSW1wb3J0cygpPC9hPiBhbmQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI29uRGVwbG95KGphdmF4LnNlcnZsZXQuU2VydmxldENvbnRleHQpIj5vbkRlcGxveSgpPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL1BhZ2VJbXBvcnRzLmh0bWwiPlBhZ2VJbXBvcnRzPC9hPg0KICAgICAgICBvYmplY3QgdG8gYXV0b21hdGljYWxseSByZW5kZXIgY29udHJvbCBIVE1MIGhlYWRlciBpbXBvcnRzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgZm9ybSBiYWNrIGJ1dHRvbiBzdXBwb3J0LiBTZWUgRm9ybSANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjb25TdWJtaXRDaGVjayhvcmcuYXBhY2hlLmNsaWNrLlBhZ2UsIGphdmEubGFuZy5TdHJpbmcpIj5vblN1Ym1pdENoZWNrKCk8L2E+DQogICAgICAgIEFQSSBmb3IgZGV0YWlscy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGZ1bGwgSlNQIENsaWNrIFBhZ2UgaW50ZWdyYXRpb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNCI+MjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUmVnZXhGaWVsZC5odG1sIj5SZWdleEZpZWxkPC9hPiANCiAgICAgICAgcHJvdmlkZWQgYnkgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2Ij40NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9Qcm9wZXJ0eVNlbGVjdC5odG1sIj5Qcm9wZXJ0eVNlbGVjdDwvYT4NCiAgICAgICAgcHJvdmlkZWQgYnkgQWhtZWQgTW9ob21iZS4gUGxlYXNlIHNlZSBDbGljayBDYXllbm5lIHdlYiBhcHBsaWNhdGlvbiBmb3INCiAgICAgICAgYSBkZW1vbnN0cmF0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgSmFwYW5lc2UgbWVzc2FnZSByZXNvdXJjZXMgcHJvdmlkZWQgYnkgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ0Ij40NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgR2VybWFuIG1lc3NhZ2UgcmVzb3VyY2VzIHByb3ZpZGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTUiPjU1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBjbGljay1leGFtcGxlcyBUYWJsZSB3aXRoIEZvcm0gZmllbGRzIGRlbW9uaXN0cmF0aW9uIHByb3ZpZGVkIGJ5IA0KICAgICAgICBDaHJpc3RpYW4gRXNzbC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIFVURi04IGNoYXJzZXQgaGFuZGxpbmcgcHJvdmlkZWQgYnkgTmFva2kgVGFrZXpvZSANCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NiI+NTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIEZvcm0gJmx0Oy0mZ3Q7IERBTyAgYXV0by1sb2FkaW5nIHRvIGhhbmRsZSBwcmltaXRpdmUgdHlwZXMuIA0KICAgICAgICBQcm92aWRlZCBieSBDaHJpc3RpYW4gRXNzbA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUzIj41MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBjb21tb25zLWZpbGV1cGxvYWQgdG8gdmVyc2lvbiAxLjEgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00OSI+NDk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIG51bGwgQ29sdW1uIERlY29yYXRvciBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW5kaWZpZWQgYnkgR2VvZmYgSG9wc29uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDAiPjQwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBUYWJsZSBwYWdpbmcgYnVnLiBUaGlzIGlzc3VlIHdhcyBpZGVuZGlmaWVkIGJ5IEFobWVkIE1vaG9tYmUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MSI+NDE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFRleHRGaWVsZCBjb25zdHJ1Y3RvciBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW5kaWZpZWQgYnkgQm9iIFNjaGVsbGluaw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQyIj40MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgSlNDYWxlbmRhciBwcm9ibGVtIGluIEphcGFuZXNlLiBUaGlzIGZpeCB3YXMgcHJvdmlkZWQgYnkNCiAgICAgICAgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQzIj40MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRm9ybSBGaWVsZFNldCBGaWxlRmllbGQgZW5jdHlwZSBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW5kaWZpZWQgYnkNCiAgICAgICAgQ2hyaXN0aWFuIEVzc2wNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00OCI+NDg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIHNlc3Npb24gcmV3cml0ZSBidWcgd2hlbiB1c2luZyBhYnNvbHV0ZSByZWRpcmVjdHMuIA0KICAgICAgICBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IE1haWsgSmFibG9uc2tpDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTEiPjUxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBWZWxvY2l0eSBSdW50aW1lRXhjZXB0aW9uIGhhbmRsaW5nIGJ1Zw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHA6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9WRUxPQ0lUWS00MjQiPlZFTE9DSVRZLTQyNDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgVmVsb2NpdHkgMS41LWRldiBhbmQgQ2F5ZW5uZSAxLjIgaW50ZXJvcGVyYWJpbGl0eSBidWcgDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cDovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL1ZFTE9DSVRZLTQyNiI+VkVMT0NJVFktNDI2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjE3IC0gNXRoIERlY2VtYmVyIDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBNb2RpZmllZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCI+Q2xpY2tTZXJ2bGV0PC9hPiANCiAgICAgICAgdG8gZW5hYmxlIGRpcmVjdCBTZXJ2bGV0UmVzcG9uc2UgaGFuZGxpbmcgYnkgDQogICAgICAgIFBhZ2VzLiBTZWUgQ2xpY2sgRXhhbXBsZXMgRGlyZWN0IFBhZ2UgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIE1vZGlmaWVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvc3ByaW5nL1NwcmluZ0NsaWNrU2VydmxldC5odG1sIj5TcHJpbmdDbGlja1NlcnZsZXQ8L2E+DQogICAgICAgIHRvIHNldCBTcHJpbmcgQXBwbGljYXRpb25Db250ZXh0IGluIHBhZ2VzIGltcGxlbWVudGluZyANCiAgICAgICAgPHR0PkFwcGxpY2F0aW9uQ29udGV4dEF3YXJlPC90dD4gaW50ZXJmYWNlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgQ2xpY2sgMC4xNiBpbnRlZ3JhdGlvbiBpc3N1ZXMgd2l0aCBWZWxvY2l0eSAxLjUtZGV2IHNuYXBzaG90IGFuZCANCiAgICAgICAgQ2F5ZW5uZSAxLjIuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZWdpc3RlcmVkIENsaWNrIEpBUnMgd2l0aCAgDQogICAgICAgIDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuaWJpYmxpby5vcmcvbWF2ZW4vbmV0LnNmLmNsaWNrL2phcnMvIj5JYmlibGlvIE1hdmVuPC9hPiBSZXBvc2l0b3J5Lg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMTYgLSAybmQgRGVjZW1iZXIgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIGNvbnRyb2wgbG9jYWxpemF0aW9uIHN1cHBvcnQsIHBsZWFzZSBzZWUgDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNnZXRMYWJlbCgpIj5GaWVsZDwvYT4NCiAgICAgICAgSmF2YWRvYyBhbmQgPGEgaHJlZj0iZmFxLmh0bWwjbG9jYWxpemF0aW9uIj5GQVE8L2E+IGZvciBkZXRhaWxzLg0KICAgICAgICA8cC8+DQogICAgICAgIFRoaXMgZmVhdHVyZSBiYXNlZCBvbiBhIGNvbmNlcHQgZGV2ZWxvcGVkIGJ5IEFobWVkIE1vaG9tYmUsDQogICAgICAgIGFuZCByZXBsYWNlcyB0aGUgPHR0PiJtc2c6IjwvdHQ+IHByZWZpeCBsb2NhbGl6YXRpb24gZnVuY3Rpb25hbGl0eQ0KICAgICAgICBpbnRyb2R1Y2VkIGluIHJlbGVhc2UgMC4xMy4gDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBIaWJlcm5hdGUgZGF0YSBhd2FyZSBGb3JtIGNvbnRyb2wNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9oaWJlcm5hdGUvSGliZXJuYXRlRm9ybS5odG1sIj5IaWJlcm5hdGVGb3JtPC9hPiwNCiAgICAgICAgYW5kIHN1cHBvcnRpbmcNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9oaWJlcm5hdGUvU2Vzc2lvbkNvbnRleHQuaHRtbCI+U2Vzc2lvbkNvbnRleHQ8L2E+IGFuZA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2hpYmVybmF0ZS9TZXNzaW9uRmlsdGVyLmh0bWwiPlNlc3Npb25GaWx0ZXI8L2E+IGNsYXNzZXMuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgTWVudSANCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCNwYWdlcyI+cGFnZXM8L2E+DQogICAgICAgIHByb3BlcnR5IGZvciBzZWxlY3RpbmcgbWVudSBpdGVtcy4gVGhpcyBmZWF0dXJlIHdhcyBwcm92aWRlZCBieSANCiAgICAgICAgR2VvZmYgSG9wc29uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzkiPjM5PC9hPl0uDQogICAgICAgIDxwLz4NCiAgICAgICAgUmVmYWN0b3JlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTWVudS5odG1sIj5NZW51PC9hPg0KICAgICAgICB0byBpbXBsZW1lbnQgQ29udHJvbCBpbnRlcmZhY2UgdG8gaW1wcm92ZSBQYWdlIHN1YmNsYXNzaW5nLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgRm9ybSByZW5kZXJpbmcgZmxleGliaWxpdHkgd2l0aCBuZXcgcHJvcGVydGllcw0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNnZXRMYWJlbFJlcXVpcmVkUHJlZml4KCkiPmxhYmVsUmVxdWlyZWRQcmVmaXg8L2E+DQogICAgICAgIGFuZA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNnZXRMYWJlbFJlcXVpcmVkU3VmZml4KCkiPmxhYmVsUmVxdWlyZWRTdWZmaXg8L2E+LiAgICAgICAgDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9TZWxlY3QuaHRtbCNzZXRNdWx0aXBsZVZhbHVlcyhqYXZhLnV0aWwuTGlzdCkiPlNlbGVjdDwvYT4NCiAgICAgICAgPHR0PnNldE11bHRpcGxlVmFsdWVzKCk8L3R0PiBtZXRob2QuIFRoaXMgaXNzdWUgd2FzIGlkZW5kaWZpZWQgYnkNCiAgICAgICAgR2VvZmYgSG9wc29uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQiPjM0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBDb250ZXh0DQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNjcmVhdGVQYWdlKGphdmEubGFuZy5DbGFzcykiPmNyZWF0ZVBhZ2UoKTwvYT4NCiAgICAgICAgbWV0aG9kIGVuYWJsaW5nIHlvdSB0byBzcGVjaWZ5IHRoZSB0YXJnZXQgcGFnZSBieSBjbGFzcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+QWRkZWQgY3VzdG9tIHJpY2ggdGV4dCBhcmVhIGNvbnRyb2wgZGVtb25zdHJhdGlvbiANCiAgICAgICAgaW4gQ2xpY2sgRXhhbXBsZXMgRW1haWwgRm9ybSBwYWdlLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIENvbHVtbiBudWxsIHZhbHVlIGhhbmRsaW5nIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbmRpZmllZCBieQ0KICAgICAgICBHZW9mZiBIb3Bzb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMiI+MzI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEFjdGlvbkxpbmsgdmFsdWUgZXNjYXBpbmcgYnVnLiBUaGlzIGlzc3VlIHdhcyBpZGVuZGlmaWVkIGJ5DQogICAgICAgIEdlb2ZmIEhvcHNvbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMzIj4zMzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRGF0ZUZpZWxkIEkxOE4gaXNzdWUgYW5kIGltcHJvdmVkIHJlbmRlcmluZy4gVGhlc2UgaXNzdWVzIHdlcmUgDQogICAgICAgIGlkZW5kaWZpZWQgYnkgQW50b25pIEFsb3kgYW5kIEFobWVkIE1vaG9tYmUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNiI+MzY8L2E+LA0KICAgICAgICAgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3Ij4yNzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTW9kaWZpZWQgRm9ybWF0IA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0Zvcm1hdC5odG1sI2dldEVtcHR5U3RyaW5nKCkiPmdldEVtcHR5U3RyaW5nKCk8L2E+DQogICAgICAgIHRvIHJldHVybiAiIiBzdHJpbmdzIHRvIGJldHRlciBzdXBwb3J0IEFKQVggcmVuZGVyaW5nLiANCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgaWRlbmRpZmllZCBieSBBbmRydXMgQWRhbWNoaWsuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPiANCiAgPGR0PlZlcnNpb24gMC4xNSAtIDI1dGggT2N0b2JlciAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgZXNjYXBpbmcgcXVvdGUgY2hhcmFjdGVycyBpbiBjb250cm9scy4gVGhpcyBpc3N1ZSB3YXMgaWRlbmRpZmllZCBieQ0KICAgICAgICBNaWtlIE9yZ2FuZWsNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMSI+MzE8L2E+XS48YnIvPg0KICAgICAgICBBZGRlZCBuZXcgDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvSHRtbFN0cmluZ0J1ZmZlci5odG1sIj5IdG1sU3RyaW5nQnVmZmVyPC9hPg0KICAgICAgICBjbGFzcyBmb3IgY29udHJvbCByZW5kZXJpbmcuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBjbGljay1jYXllbm5lIDxhIGhyZWY9ImV4YW1wbGVzLmh0bWwiPmV4YW1wbGU8L2E+IHdlYiBhcHBsaWNhdGlvbi4gDQogICAgICAgIFRoaXMgYXBwbGljYXRpb24gd2FzIGNvbnRyaWJ1dGVkIGJ5IEFuZHJ1cyBBZGFtY2hpay4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZWZhY3RvcmVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sIj5Gb3JtPC9hPiANCiAgICAgICAgYWxpZ24gYW5kIHBvc2l0aW9uIGNvbnN0YW50cyB0byByZW1vdmUgYW1iaWd1aXR5Lg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIENsaWNrQXBwIE5QRSB3aGVuIGluaXRpYWxpemluZw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMwIj4zMDwvYT5dLA0KICAgICAgICByZWxhdGVkIFZlbG9jaXR5IEVuZ2luZSBwYXRjaGVzIGFwcGxpZWQgDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cDovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL1ZFTE9DSVRZLTQxMiI+NDEyPC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgUmVmYWN0b3JlZCBBbnQgYnVpbGQgc3lzdGVtLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8ZHQ+VmVyc2lvbiAwLjE0IC0gMTd0aCBPY3RvYmVyIDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjAuNWVtOyI+IE5ldyBkZXZlbG9wZXINCiAgICA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL2Ftb2hvbWJlLyI+QWhtZWQgTW9ob21iZTwvYT4NCiAgICBqb2lucyB0aGUgQ2xpY2sgcHJvamVjdC48L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEZpZWxkU2V0IEZvcm0gcHJvY2Vzc2luZyBidWcuIFRoZSBidWcgd2FzIGlkZW50aWZpZWQgYnkgYnkgUGF1bCBSdWxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjUiPjI1PC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgUmVtb3ZlZCBKRE9NIGRlcGVuY2VuY3kuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVmVsb2NpdHkgRW5naW5lIGVycm9yIHJlcG9ydGluZyBwYXRjaGVzIGFwcGxpZWQgDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cDovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL1ZFTE9DSVRZLTM3MyI+MzczPC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTW9kaWZpZWQgQW50IGJ1aWxkIHNjcmlwdCB0byBkb3dubG9hZCBKQVIgZGVwZW5kZW5jaWVzIGZyb20gDQogICAgICAgIDxhIGhyZWY9Imh0dHA6Ly93d3cuaWJpYmxpby5vcmcvbWF2ZW4vIj5JYmlibGlvPC9hPiBNYXZlbiByZXBvc2l0b3J5Lg0KICAgICAgPC9saT4gICAgDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPGR0PlZlcnNpb24gMC4xMyAtIDEzdGggT2N0b2JlciAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgU3ByaW5nIGludGVncmF0aW9uIHNlcnZsZXQNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9zcHJpbmcvU3ByaW5nQ2xpY2tTZXJ2bGV0Lmh0bWwiPlNwcmluZ0NsaWNrU2VydmxldDwvYT4uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgQ2F5ZW5uZSBkYXRhIGF3YXJlIEZvcm0gY29udHJvbA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvQ2F5ZW5uZUZvcm0uaHRtbCI+Q2F5ZW5uZUZvcm08L2E+Lg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIEpTUCBzdXBwb3J0LiBTZWUgDQogICAgICAgIDxhIGhyZWY9ImZhcS5odG1sI2pzcC1zdXBwb3J0Ij5GQVE8L2E+DQogICAgICAgIGZvciBkZXRhaWxzIGFuZCBDbGljayBFeGFtcGxlcyBmb3IgYSBkZW1vbnN0cmF0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgDQoJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI3NldExhYmVsKGphdmEubGFuZy5TdHJpbmcpIj5GaWVsZDwvYT4NCglsb2NhbGl6YXRpb24gc3VwcG9ydCwgc2VlIDxhIGhyZWY9ImZhcS5odG1sI2xvY2FsaXphdGlvbiI+RkFRPC9hPiBmb3IgZGV0YWlscy4NCglCYXNlZCBvbiBhIGNvbmNlcHQgYnkgSWFpbiBTaGlnZW9rYS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEZpZWxkU2V0IEZvcm0gJmx0Oy0mZ3Q7IERBTyBhdXRvLWxvYWRpbmcgYnVnLiBUaGUgZml4IHdhcyBwcm92aWRlZCANCiAgICAgICAgYnkgUGF1bCBSdWxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjAiPjIzPC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgV2ViU3BoZXJlJ3MgYnVuZGxlZCBKRE9NIDAuNyBjb21wYXRhYmlsaXR5IGlzc3VlLiBUaGlzIGlzc3VlIHdhcw0KICAgICAgICBpZGVudGlmaWVkIGJ5IE9saXZlciBCdXJuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjAiPjI1PC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBKYWthcnRhIENvbW1vbnMgSkFScyB0byBsYXRlc3QgdmVyc2lvbnMgdG8gc3VwcG9ydCBIaWJlcm5hdGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOSI+MTk8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZW1vdmVkIENvbW1vbnMgTG9nZ2luZyBkZXBlbmRlbmN5IGluIENsaWNrIEV4dHJhcyB0byBhdm9pZCBXZWJTcGhlcmUNCiAgICAgICAgY2xhc3MgbG9hZGluZyBpc3N1ZXMNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMCI+MjA8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIFZlbG9jaXR5IDEuNSBkZXYgYnVpbGQgdG8gdXNlIHJlY2VudCBzbmFwc2hvdA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIxIj4yMTwvYT5dLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIE5QRSBidWcgaW4gRXJyb3JSZXBvcnQuIFRoaXMgZml4IHdhcyBwcm92aWRlZCBieSBTdGV2ZSBDb3d4Lg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMTIgLSAxc3QgT2N0b2JlciAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkU2V0Lmh0bWwiPkZpZWxkU2V0PC9hPiANCiAgICAgICAgY29udHJvbC4gU2VlIEphdmFkb2MgZm9yIGRldGFpbHMgYW5kIENsaWNrIEV4YW1wbGVzIGZvciBhIGRlbW9uc3RyYXRpb24gDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00Ij5DTEstNDwvYT5dLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZCBGaWVsZCA8dHQ+Im5hbWUiPC90dD4gYW5kIDx0dD4ibGFiZWwiPC90dD4gY29uc3RydWN0b3JzIGFkZGVkIHRvIA0KICAgICAgICBtYWtlIEZvcm0gJmx0Oy0mZ3Q7IERBTyBhdXRvLWxvYWRpbmcgZWFpc2VyIHRvIHVzZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIENoYW5nZWQgY29udHJvbHMgdG8gcmVuZGVyIHZhbGlkIFhIVE1MLCBpbnN0ZWFkIG9mIEhUTUwgNC4wMSwgZW5hYmxpbmcNCiAgICAgICAgRmlyZWZveCBhbmQgTWFjIE9TIFggIGJyb3dzZXJzIHRvIHJlbmRlciBBSkFYIHJlc3BvbnNlcyBjb250YWluaW5nIENvbnRyb2wNCiAgICAgICAgSFRNTA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMiPkNMSy0zPC9hPl0uDQogICAgICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgICAgRm9yIGV4YW1wbGUgdGhlIFRleHRGaWVsZCBIVE1MICZuYnNwOyA8dHQ+Jmx0O2lucHV0IHR5cGU9J3RleHQnIGRpc2FibGVkJmd0OzwvdHQ+IA0KICAgICAgICAmbmJzcDsgbm93IHJlbmRlcnMgYXMgPGJyLz4gPHR0PiZsdDtpbnB1dCB0eXBlPSd0ZXh0JyBkaXNhYmxlZD0nZGlzYWJsZWQnLyZndDs8L3R0PiA8L2Rpdj4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIGJ1ZyB3aGVyZSBtdWx0aXBhcnQgZm9ybSBwYXJhbWV0ZXJzIG5vdCBhdmFpbGFibGUgZHVyaW5nIA0KICAgICAgICA8dHQ+UGFnZS5vbkluaXQoKTwvdHQ+IA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEiPkNMSy0xPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjExIC0gMTZ0aCBTZXB0ZW1iZXIgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCI+TWVudTwvYT4gY29tcG9uZW50Lg0KICAgICAgCVNlZSBKYXZhZG9jIGZvciBkZXRhaWxzIGFuZCBDbGljayBFeGFtcGxlcyBmb3IgYSBkZW1vbnN0cmF0aW9uIA0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTIiPkNMSy0xMjwvYT5dLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgcnVudGltZSA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI3BhZ2UtYXV0by1sb2FkaW5nIj5QYWdlIEF1dG8gTG9hZGluZzwvYT4NCiAgICAgICAgd2hlbiB0aGUgYXBwbGljYXRpb24gaXMgaW4NCiAgICAgICAgPHR0PiJkZXZlbG9wbWVudCI8L3R0PiwgPHR0PiJkZWJ1ZyI8L3R0PiBvciA8dHQ+InRyYWNlIjwvdHQ+IG1vZGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOCI+Q0xLLTE4PC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBGb3JtICZsdDstJmd0OyBEQU8gYXV0by1sb2FkaW5nIGZlYXR1cmUuDQogICAgICAgIFNlZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNjb3B5RnJvbShqYXZhLmxhbmcuT2JqZWN0KSI+Rm9ybTwvYT4NCiAgICAgICAgSmF2YWRvYyBmb3IgZGV0YWlscyBbPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMiI+Q0xLLTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIGJsYW5rIHBhZ2UgZ3ppcCBjb21wcmVzc2lvbiBidWcuIFRoZSBDbGljayBlbWJlZGRlZCBnemlwIGNvbXByZXNzaW9uIA0KICAgICAgICBmdW5jdGlvbmFsaXR5IGhhcyBiZWVuIHJlcGxhY2VkIHdpdGggYQ0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2ZpbHRlci9Db21wcmVzc2lvbkZpbHRlci5odG1sIj5Db21wcmVzc2lvbkZpbHRlcjwvYT4NCiAgICAgICAgZGVyaXZlZCBmcm9tIEphcmthdGEgVG9tY2F0DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNSI+Q0xLLTU8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCA8dHQ+ZW1haWwoKTwvdHQ+IGFuZCA8dHQ+bGluaygpPC90dD4gZm9ybWF0dGVyIG1ldGhvZHMgYW5kDQogICAgICAgIDx0dD5nZXRFbXB0eVN0cmluZygpPC90dD4gbWV0aG9kIHRvDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvRm9ybWF0Lmh0bWwjZW1haWwoamF2YS5sYW5nLlN0cmluZykiPkZvcm1hdDwvYT4gY2xhc3MNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNSI+Q0xLLTE1PC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTW9kaWZpZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwiPkZvcm08L2E+DQogICAgICAgIGNvbnRyb2wgdG8gcmVuZGVyIGEgY2xhc3MgZXJyb3IgYXR0cmlidXRlICZsdDtsYWJlbCBjbGFzcz0iZXJyb3IiJmd0OyANCiAgICAgICAgaW4gdGhlIGxhYmVscyBvZiBpbnZhbGlkIGZpZWxkcy4gWW91IGNhbiBub3cgb3ZlcnJpZGUgdGhlIDx0dD5jb250cm9sLmNzczwvdHQ+DQogICAgICAgIHN0eWxlIDx0dD5sYWJlbC5lcnJvcjwvdHQ+IHRvIG1vZGlmeSB0aGUgZGlzcGxheSBvZiBmaWVsZCBlcnJvciBsYWJlbHMuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTW9kaWZpZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjRm9ybShqYXZhLmxhbmcuU3RyaW5nKSI+Rm9ybTwvYT4NCiAgICAgICAgY29uc3RydWN0b3IgdG8gb25seSByZXF1aXJlIGZvcm0gbmFtZSBwYXJhbWV0ZXIuIFRoZSBjb250ZXh0IGNhbiBiZQ0KICAgICAgICBzZXQgbGF0ZXIuIE5vdGUgdGhpcyB3aWxsIHJlcXVpcmUgbW9kaWZpY2F0aW9ucyB0byBleGl0aW5nIGNvZGUuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4xMCAtIDFzdCBTZXB0ZW1iZXIgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MC41ZW07Ij4gTmV3IGRldmVsb3Blcg0KICAgIDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdXNlcnMvcGJhcm5lcy8iPlBoaWwgQmFybmVzPC9hPiANCiAgICBqb2lucyB0aGUgQ2xpY2sgcHJvamVjdC48L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9wYW5lbC9wYWNrYWdlLXN1bW1hcnkuaHRtbCI+UGFuZWw8L2E+IA0KICAgICAgICBjb21wb25lbnRzIGJ5IFBoaWwgQmFybmVzLiBTZWUgSmF2YWRvYyBmb3IgZGV0YWlscyBhbmQgQ2xpY2sgRXhhbXBsZXMgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCI+VGFibGU8L2E+IGNvbnRyb2wuDQogICAgICAJU2VlIEphdmFkb2MgZm9yIGRldGFpbHMgYW5kIENsaWNrIEV4YW1wbGVzIGZvciBhIGRlbW9uc3RyYXRpb24gDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3RyYWNrZXIvaW5kZXgucGhwP2Z1bmM9ZGV0YWlsJmFpZD0xMjQzMjQzJmdyb3VwX2lkPTgyMDk1JmF0aWQ9NTY1MDI3Ij4xMjQzMjQzPC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ltYWdlU3VibWl0Lmh0bWwiPkltYWdlU3VibWl0PC9hPiANCiAgICAgICAgY29udHJvbCBieSBQaGlsIEJhcm5lcy4gU2VlIEphdmFkb2MgZm9yIGRldGFpbHMgYW5kIENsaWNrIEV4YW1wbGVzIGZvciBhIGRlbW9uc3RyYXRpb24uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTG9jYWxpemF0aW9uL0kxOE4gY2hhbmdlcyBpbmNsdWRlOg0KICAgICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOjAuNWVtOyI+DQogICAgICAgIEFkZGVkIENoaW5lc2UgbG9jYWxpemF0aW9uIHByb3BlcnRpZXMgKHpoX0NOKSBwcm92aWRlZCBieSBYaSBQaW5nIFdhbmcuIDwvZGl2Pg0KICAgICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOjAuNWVtOyI+DQogICAgICAgIEFkZGVkIFBhZ2UgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9NZXNzYWdlc01hcC5odG1sIj5NZXNzYWdlc01hcDwvYT4NCiAgICAgICAgYWRhcHRvciB0byBWZWxvY2l0eSBDb250ZXh0Lg0KICAgICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOjAuNWVtOyI+DQogICAgICAJQWRkZWQgbmV3IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNnZXRMb2NhbGUoKSI+Z2V0TG9jYWxlKCk8L2E+DQogICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwjc2V0TG9jYWxlKGphdmEudXRpbC5Mb2NhbGUpIj5zZXRMb2NhbGUoKTwvYT4NCiAgICAgICAgbWV0aG9kcyB0byBDb250ZXh0IGNsYXNzIHRvIGVuYWJsZSBvdmVycmlkaW5nIHRoZSBkZWZhdWx0IHJlcXVlc3QgTG9jYWxlLiA8L2Rpdj4NCiAgICAgIDwvbGk+ICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlOZXcgPGEgaHJlZj0iZXh0cmFzLWFwaS9vdmVydmlldy1zdW1tYXJ5Lmh0bWwiPkNsaWNrIEV4dHJhczwvYT4gbW9kdWxlIGFuZCBKQVIgcHJvdmlkZWQgZm9yDQogICAgICAgIGNvbnRyaWJ1dGlvbnMgYW5kIG5vbi1jb3JlIGZyYW1ld29yayBjb21wb25lbnRzLg0KICAgICAgPC9saT4gICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlOZXcgUmljbyBpbnNwaXJlZCBBSkFYIExpdmUgR3JpZCBleGFtcGxlIHByb3ZpZGVkIGJ5IFBoaWwgQmFybmVzLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQ2xpY2sgRXhhbXBsZXMsIENvbmZsdWVuY2UgV0lLSSBhbmQgSklSQSBhcHBsaWNhdGlvbnMgYXJlIG5vdyBhdmlsYWJsZSBvbmxpbmUuIA0KICAgICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOjAuNWVtOyI+DQogICAgICAgIFNwZWNpYWwgdGhhbmtzIHRvIFBoaWwgQmFybnMgZm9yIGhvc3RpbmcgdGhlc2UgYXBwbGljYXRpb25zLiA8L2Rpdj4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjkgLSA3dGggQXVndXN0IDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIGFwcGxpY2F0aW9uIHJlbG9hZGluZyBmZWF0dXJlIHRvIHJlbG9hZCAiY2xpY2sueG1sIiB3aXRob3V0DQogICAgICAJcmVzdGFydGluZyB0aGUgd2ViIGFwcGxpY2F0aW9uLg0KICAgICAgCVNlZSANCiAgICAgIAk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNhcHAtcmVsb2FkaW5nIj5DbGlja1NlcnZsZXQ8L2E+DQogICAgICAJSmF2YWRvYyBmb3IgZGV0YWlscyBhbmQgdGhlIENsaWNrIEV4YW1wbGVzIGZvciBhIGRlbW9uc3RyYXRpb24gDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3RyYWNrZXIvaW5kZXgucGhwP2Z1bmM9ZGV0YWlsJmFpZD0xMjUwOTc4Jmdyb3VwX2lkPTgyMDk1JmF0aWQ9NTY1MDI3Ij4xMjM3OTQyPC9hPl0uDQogICAgICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgICAgVGhpcyBjb25jZXB0IHdhcyBkZWZpbmVkIGJ5IDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdXNlcnMvaGFuc2JhZWNrZXJtLyI+SGFucyBCYWVja2VyLU1heWVyPC9hPi4gPC9kaXY+DQogICAgICA8L2xpPiAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC44IC0gMm5kIEF1Z3VzdCAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9zZXJ2aWNlL0xvZ1NlcnZpY2UuaHRtbCI+TG9nU2VydmljZTwvYT4NCiAgICAgIAl3aGljaCBsb2dzIHRvIHRoZSBjb25zb2xlIGJ5IGRlZmF1bHQuIA0KICAgICAgCVNlZSB0aGUgQ2xpY2sgYW5kICBWZWxvY2l0eSA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2NsaWNrLWxvZ2dpbmciPkxvZ2dpbmc8L2E+DQogICAgICAJdG9waWMuDQogICAgICA8L2xpPiAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC43IC0gMjh0aCBKdWx5IDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIA0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWxlRmllbGQuaHRtbCI+RmlsZUZpZWxkPC9hPg0KICAgICAgICAgY29udHJvbCBmb3IgdXBsb2FkaW5nIGZpbGVzIGFuZCBtb2RpZmllZCBGb3JtIGNvbnRyb2wgdG8gc3VwcG9ydCANCiAgICAgICAgICJtdWx0aXBhcnQvZm9ybS1kYXRhIiByZXF1ZXN0cy4gU2VlIHRoZSBDbGljayBFeGFtcGxlcyANCiAgICAgICAgIEZpbGUgVXBsb2FkIHBhZ2UgZm9yIGEgZGVtb25zdHJhdGlvbiBbPGEgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC90cmFja2VyL2luZGV4LnBocD9mdW5jPWRldGFpbCZhaWQ9MTIzNzk0MiZncm91cF9pZD04MjA5NSZhdGlkPTU2NTAyNyI+MTIzNzk0MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlcyI+DQogICAgICAgIEFkZGVkIHBhZ2VzIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAyLmh0bWwjYXBwbGljYXRpb24tYXV0b21hcHBpbmciPkF1dG8gTWFwcGluZzwvYT4NCiAgICAgICAgY29uZmlndXJhdGlvbiBvcHRpb24uIFRoaXMgZmVhdHVyZSBjYW4gYXV0b21hdGljYWxseSBtYXAgSFRNTCBwYWdlDQogICAgICAgIHRlbXBsYXRlcyB0byBQYWdlIGNsYXNzZXMgc28geW91IGRvbnQgaGF2ZSB0byBkZWNsYXJlIHRoZW0gbWFudWFsbHkgaW4NCiAgICAgICAgdGhlIGNsaWNrLnhtbCBjb25maWd1cmF0aW9uIGZpbGUuIA0KICAgICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOjAuNWVtOyI+DQogICAgICAgIFRoaXMgY29uY2VwdCB3YXMgZGVmaW5lZCBieSA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL2Ftb2hvbWJlLyI+QWhtZWQgTW9ob21iZTwvYT4uIDwvZGl2Pg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlcyI+DQogICAgICAgIEFkZGVkIA0KICAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMwNS5odG1sI3BhZ2UtZm9yd2FyZGluZyI+UGFnZSBGb3J3YXJkaW5nPC9hPg0KICAgICAgICBlbmFibGluZyB5b3UgdG8gY29uZmlndXJlIHRoZSBQYWdlIHRvIGZvcndhcmQgdGhlIHJlcXVlc3QgdG8uDQogICAgICAgIFRoaXMgcHJvdmlkZXMgc2ltaWxhciBmdW5jdGlvbmFsaXR5IGFzIFRhcGVzdHJ5J3MgPHR0PmN5Y2xlLmdldFBhZ2UoKTwvdHQ+DQogICAgICAgIGludGVycGFnZSBjYWxsaW5nIHRlY2huaXF1ZS4gU2VlIHRoZSBFeGFtcGxlcyBQYWdlDQogICAgICAgIEZsb3cgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZXMiPg0KICAgICAgICBBZGRlZCANCiAgICAgICAgQ2xpY2tTZXJ2bGV0IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NsaWNrU2VydmxldC5odG1sI25ld1BhZ2VJbnN0YW5jZShqYXZhLmxhbmcuQ2xhc3MsIGphdmF4LnNlcnZsZXQuaHR0cC5IdHRwU2VydmxldFJlcXVlc3QpIj5uZXdQYWdlSW5zdGFuY2UoKTwvYT4NCiAgICAgICAgbWV0aG9kIHRvIHN1cHBvcnQgSW9DIGFwcGxpY2F0aW9ucy4gU2VlIHRoZSANCiAgICAgICAgPGEgaHJlZj0iZmFxLmh0bWwjc3ByaW5nLWludGVncmF0aW9uIj5TcHJpbmcgSW50ZWdyYXRpb248L2E+IEZBUSB0b3BpYyBmb3IgbW9yZSBkZXRhaWxzLg0KICAgICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOjAuNWVtOyI+DQogICAgICAgIFRoaXMgY29uY2VwdCB3YXMgZGVmaW5lZCBieSA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL3BiYXJuZXMvIj5QaGlsIEJhcm5lczwvYT4uIDwvZGl2Pg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlcyI+DQogICAgICAgIEZvcm0gcmVuZGVyaW5nIGltcHJvdmVkIHRvIGluY2x1ZGUgQ1NTIGNsYXNzZXMgImZpZWxkcyIsICJlcnJvcnMiIGFuZCAiYnV0dG9ucyIgDQogICAgICAgIGluIHRoZSByZXNwZWN0aXZlIHRhYmxlICZsdDt0ciZndDsgYW5kICZsdDt0ZCZndDsgZWxlbWVudHMuIFRoaXMgZW5hYmxlcyBncmVhdGVyDQogICAgICAgIGNvbnRyb2wgb2YgRm9ybSBkaXNwbGF5IHVzaW5nIENTUyBzdHlsZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCAidHJhY2UiIGFwcGxpY2F0aW9uIG1vZGUgdG8gcHJvdmlkZSBtb3JlIGRldGFpbGVkIGxvZ2dpbmcuDQogICAgICAgIFNlZSB0aGUgQ29uZmlndXJhdGlvbiA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2FwcGxpY2F0aW9uLW1vZGUiPk1vZGU8L2E+IHRvcGljLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0Zvcm1hdC5odG1sI2xpbWl0TGVuZ3RoKGphdmEubGFuZy5TdHJpbmcsIGludCkiPmxpbWl0TGVuZ3RoKCk8L2E+DQogICAgICAgIG1ldGhvZHMgdG8gdGhlIEZvcm1hdCBjbGFzcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIFN1Ym1pdCBjb250cm9scyBwcm9jZXNzaW5nIG9mIEhUTUwgY2hhcmFjdGVycy4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjYgLSAybmQgSnVseSAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZCBBSkFYIER5bmFtaWMgSFRNTCBhbmQgWE1MIHJlcXVlc3QgZXhhbXBsZSB1c2luZw0KICAgICAgICAgdGhlIHVzaW5nIFJpY28gQWpheCBsaWJyYXJ5LiBTZWUgdGhlIENsaWNrIEV4YW1wbGVzIEFKQVggcGFnZSBmb3IgYSBkZW1vbnN0cmF0aW9uLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL09wdGlvbi5odG1sIj5PcHRpb248L2E+IGFuZCANCiAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvT3B0aW9uR3JvdXAuaHRtbCI+T3B0aW9uR3JvdXA8L2E+IA0KICAgICAgICAgIHJlZmFjdG9yZWQgaW50byBzdGFuZGFsb25lIGNsYXNzZXMuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgIEFkZGVkIFBhZ2UgDQogICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0SGVhZGVyKGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5PYmplY3QpIj5zZXRIZWFkZXIoKTwvYT4NCiAgICAgICAgIG1ldGhvZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+Rml4ZWQgTlBFIHdoZW4gRmllbGRzLCB3aXRoIG5vIHBhcmVudCBGb3JtLCBhcmUgcHJvY2Vzc2VkDQogICAgICAgICBhbmQgcmVuZGVyZWQuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZCBGQVEsIGFuZCB1cGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+ICAgDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjUgLSAxc3QgSnVuZSAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5Gb3JtIGNvbnRyb2wgZW5jb2RlcyB0aGUgZm9ybSA8dHQ+ImFjdGlvbiI8L3R0PiBVUkwgYXR0cmlidXRlIHVzaW5nDQogICAgICAgICA8YSBjbGFzcz0iZXh0ZXJuYWwiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vamF2YS5zdW4uY29tL3Byb2R1Y3RzL3NlcnZsZXQvMi4zL2phdmFkb2MvamF2YXgvc2VydmxldC9odHRwL0h0dHBTZXJ2bGV0UmVzcG9uc2UuaHRtbCNlbmNvZGVVUkwoamF2YS5sYW5nLlN0cmluZykiPmVuY29kZVVSTChTdHJpbmcpPC9hPg0KICAgICAgICAgdG8gZW5zdXJlIHNlc3Npb24gSUQgaXMgc2V0Lg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+QWRkZWQgb3B0aW9uYWwgRm9ybSB2YWxpZGF0aW9uLiBBIA0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjdmFsaWRhdGUiPnZhbGlkYXRlPC9hPg0KICAgICAgICAgcHJvcGVydHkgaGFzIGJlZWQgYWRkZWQgdG8gRm9ybSBhbmQgYSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwjdmFsaWRhdGUoKSI+dmFsaWRhdGUoKTwvYT4NCiAgICAgICAgIG1ldGhvZCB0byBGaWVsZC4gRmllbGQgc3ViY2xhc3NlcyBoYXZlIGJlZW4gbW9kaWZpZWQgdG8gc3VwcG9ydCBvcHRpb25hbA0KICAgICAgICAgdmFsaWRhdGlvbi4gIFNlZSB0aGUgQ2xpY2sgRXhhbXBsZXMgRm9ybSBQcm9wZXJ0aWVzIHBhZ2UgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIFNlc3Npb24gT2JqZWN0IHV0aWxpdHkgbWV0aG9kcyB0byBDb250ZXh0LCBzZWUgDQogICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwjZ2V0U2Vzc2lvbk9iamVjdChqYXZhLmxhbmcuQ2xhc3MpIj5nZXRTZXNzaW9uT2JqZWN0PC9hPi4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIGVycm9yIG1lc3NhZ2UgYmxvY2sgaG9yaXpvbnRhbCBhbGlnbm1lbnQgcHJvZXBydHkNCiAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2Vycm9yc0FsaWduIj5lcnJvcnNBbGlnbjwvYT4NCiAgICAgICAgIHRvIEZvcm0uDQogICAgICA8L2xpPiAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiAgIA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC40IC0gTWF5IDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkltcGxlbWVudGVkIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAyczA2Lmh0bWwjcGFnZS10ZW1wbGF0aW5nIj5QYWdlIFRlbXBsYXRpbmc8L2E+DQogICAgICAgICBjYXBhYmlsaXR5LiBFbmFibGluZyB5b3UgdG8gY3JlYXRlIGEgc3RhbmRhcmRpemVkIGxvb2sgYW5kIGZlZWwgZm9yIHlvdXIgd2ViIA0KICAgICAgICAgYXBwbGljYXRpb24gYW5kIGdyZWF0bHkgcmVkdWNpbmcgdGhlIGFtb3VudCBvZiBIVE1MIHlvdSBuZWVkIHRvIG1haW50YWluLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5JbXByb3ZlZCBFcnJvciBoYW5kbGluZy4gQXBwbGljYXRpb24gZXhjZXB0aW9ucyByZW5kZXINCiAgICAgICAgIGVycm9yIHNvdXJjZSBsaW5lIHdoZW4gSmF2YSBzb3VyY2UgYXZhaWxhYmxlLiBGb3IgZXhhbXBsZSBhDQogICAgICAgICA8YSBocmVmPSJlcnJvci1ucGUuaHRtbCI+TnVsbFBvaW50ZXJFeGNlcHRpb248L2E+LiAgICANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+SW50ZWdyYXRlZCB0aGUgREhUTUwgQ2FsZW5kYXIgd2lkZ2V0IGJ5IDxhIGhyZWY9Imh0dHA6Ly93d3cuZHluYXJjaC5jb20vIj5EeW5hLmNvbTwvYT4NCiAgICAgICAgIGludG8gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0RhdGVGaWVsZC5odG1sIj5EYXRlRmllbGQ8L2E+IGNvbnRyb2wuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIEZvcm0gYW5kIEZpZWxkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNyZWFkb25seSI+cmVhZG9ubHk8L2E+IA0KICAgICAgICAgcHJvcGVydHkuIE1vZGlmaWVkIEZpZWxkIHN1YmNsYXNzZXMgdG8gcmVuZGVyIHRoZWlyIEhUTUwgcmVhZG9ubHkgYXR0cmlidXRlLiBJZiB0aGUgRm9ybSBpcyBzZXQgdG8NCiAgICAgICAgIHJlYWRvbmx5IGFsbCBpdHMgZmllbGRzIHdpbGwgYWxzbyBiZSByZWFkb25seS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+QWRkZWQgQ29udHJvbCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwjZ2V0SWQoKSI+Z2V0SWQoKTwvYT4gDQogICAgICAgICBtZXRob2QuIE1vZGlmaWVkIGNvbnRyb2wgY2xhc3NlcyB0byByZW5kZXIgdGhlaXIgSFRNTCBpZCBhdHRyaWJ1dGUuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIEZvcm0gPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjY29sdW1ucyI+Y29sdW1uczwvYT4gDQogICAgICAgICBwcm9wZXJ0eSB0byByZW5kZXIgZm9ybXMgaW4gbXVsdGkgY29sdW1uIHRhYmxlIGxheW91dC4gICAgDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIHBhZ2UgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3BhdGgiPnBhdGg8L2E+IA0KICAgICAgICAgcHJvcGVydHkgdG8gVmVsb2NpdHkgY29udGV4dC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+Rml4ZWQgU291cmNlVmlld2VyIG1pc3NpbmcgcmVzb3VyY2UgYnVnIHdoaWNoIG9jY3VyZWQgb24gT3Jpb24gc2VydmVyLjwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4zIC0gTWFyY2ggMjAwNTwvZHQ+DQogIDxkZD5QcmVsaW1pbmFyeSByZWxlYXNlIGZvciBwdWJsaWMgcmV2aWV3Lg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMiAtIDIwMDQ8L2R0Pg0KICA8ZGQ+DQogICAgTWFqb3IgcmV3cml0ZSwgcmVwbGFjaW5nIGNvbW1hbmQgcGF0dGVybiB3aXRoIFBhZ2Ugb3JpZW50ZWQgZGVzaWduLiBDbGljaw0KICAgIGFwcGxpY2F0aW9uIGRlc2NyaXB0b3IgcmF0aW9uYWxpemVkIGFuZCBzaW1wbGlmaWVkLg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMSAtIDIwMDM8L2R0Pg0KICA8ZGQ+SW5pdGlhbCBDbGljayB2ZXJzaW9uLiBVc2VzIENvbW1hbmQgcGF0dGVybiBhbmQgVmVsb2NpdHkgdGVtcGxhdGluZyBlbmdpbmUuDQogICAgPHAvPg0KICAgIENsaWNrIHRlYW0gYmxvZ2dpbmcgYXBwbGljYXRpb24gZGVwbG95ZWQgb24gVG9tY2F0IDQuMCBhbmQgT3JhY2xlIDlpIGFwcGxpY2F0aW9uIHNlcnZlcnMuDQogIDwvZGQ+DQogIDxwLz4NCjwvZGw+DQoNCjwvYm9keT4NCjwvaHRtbD4NCg0K