PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiIgDQogImh0dHA6Ly93d3cudzMub3JnL1RSL2h0bWw0L2xvb3NlLmR0ZCI+DQo8IS0tDQogICBMaWNlbnNlZCB0byB0aGUgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24gKEFTRikgdW5kZXIgb25lDQogICBvciBtb3JlIGNvbnRyaWJ1dG9yIGxpY2Vuc2UgYWdyZWVtZW50cy4gIFNlZSB0aGUgTk9USUNFIGZpbGUNCiAgIGRpc3RyaWJ1dGVkIHdpdGggdGhpcyB3b3JrIGZvciBhZGRpdGlvbmFsIGluZm9ybWF0aW9uDQogICByZWdhcmRpbmcgY29weXJpZ2h0IG93bmVyc2hpcC4gIFRoZSBBU0YgbGljZW5zZXMgdGhpcyBmaWxlDQogICB0byB5b3UgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlDQogICAiTGljZW5zZSIpOyB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlDQogICB3aXRoIHRoZSBMaWNlbnNlLiAgWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0DQoNCiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wDQoNCiAgIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywNCiAgIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuDQogICAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkNCiAgIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuICBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZQ0KICAgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZCBsaW1pdGF0aW9ucw0KICAgdW5kZXIgdGhlIExpY2Vuc2UuDQotLT4NCjxodG1sPg0KPGhlYWQ+DQogPCEtLSBzYXZlZCBmcm9tIHVybD0oMDAxNClhYm91dDppbnRlcm5ldCAtLT4NCiA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIi8+DQogPG1ldGEgbmFtZT0iQXV0aG9yIiBjb250ZW50PSJNYWxjb2xtIEVkZ2FyIi8+DQogPG1ldGEgbmFtZT0iZGVzY3JpcHRpb24iIGxhbmc9ImVuIiBjb250ZW50PSJBcGFjaGUgQ2xpY2sgSmF2YSB3ZWIgYXBwbGljYXRpb24gZnJhbWV3b3JrIi8+DQogPG1ldGEgbmFtZT0ia2V5d29yZHMiIGxhbmc9ImVuIiBjb250ZW50PSJBcGFjaGUgQ2xpY2ssIENsaWNrLCBDbGljayBGcmFtZXdvcmssIEphdmEsIEpFRSwgSjJFRSwgd2ViIGFwcGxpY2F0aW9uIGZyYW1ld29yaywgb3BlbiBzb3VyY2UiLz4NCiA8dGl0bGU+QXBhY2hlIENsaWNrPC90aXRsZT4NCiA8bGluayByZWw9InN0eWxlc2hlZXQiIHR5cGU9InRleHQvY3NzIiBocmVmPSIuLi9oZWxwLmNzcyIvPg0KIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgdHlwZT0idGV4dC9jc3MiIGhyZWY9Ii4uL3N5bnRheC1oaWdobGlnaHRlci5jc3MiLz4NCiA8c3R5bGUgdHlwZT0idGV4dC9jc3MiPg0KICBkbCB7DQogICAgbWFyZ2luLWxlZnQ6IDJlbTsNCiAgfQ0KICBkdCB7DQogICAgZm9udC13ZWlnaHQ6IDcwMDsNCiAgICBtYXJnaW4tdG9wOiAxLjVlbTsNCiAgICBtYXJnaW4tYm90dG9tOiAwLjVlbTsNCiAgfQ0KICAuY2hhbmdlIHsNCiAgICBtYXJnaW4tYm90dG9tOiAwLjc1ZW07DQogIH0NCiAgLnVwZ3JhZGUgew0KICAgIG1hcmdpbi1ib3R0b206IDAuNzVlbTsNCiAgICBtYXJnaW4tdG9wOiAwLjc1ZW07DQogIH0NCiAgLnJlbGVhc2UtaGVhZGVyIHsNCiAgICBiYWNrZ3JvdW5kOiAjRUZFRkY3Ow0KICAgIHBhZGRpbmc6IDRweDsNCiAgICBwYWRkaW5nLWxlZnQ6IDhweDsNCiAgICBib3JkZXI6IDFweCBzb2xpZCAjOTlBNERGOw0KICB9DQogIHByZSB7DQogICAgcGFkZGluZzogNHB4Ow0KICAgIGJvcmRlcjogMXB4IHNvbGlkICM5OUE0REY7DQogIH0NCiAgYSB7DQogIAl0ZXh0LWRlY29yYXRpb246IG5vbmU7DQogIH0NCiA8L3N0eWxlPg0KPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iLi4vc3ludGF4LWhpZ2hsaWdodGVyLmpzIj48L3NjcmlwdD4NCjwvaGVhZD4NCjwhLS1BY3RpdmF0ZSBzeW50YXggaGlnaGxpZ2h0aW5nLS0+DQogPGJvZHkgb25sb2FkPSJwcmV0dHlQcmludCgpOyI+DQoNCjxoMT5Sb2FkIE1hcCBhbmQgQ2hhbmdlczwvaDE+DQoNCjxoMj5Sb2FkIE1hcDwvaDI+DQpUaGUgbmV4dCB2ZXJzaW9uLCBDbGljayAyLjMuMCwgaXMgc2NoZWR1bGVkIGZvciBlYXJseSAyMDExLg0KVGVudGF0aXZlIGZlYXR1cmVzIGZvciB0aGUgbmV4dCByZWxlYXNlIGluY2x1ZGVzIGltcHJvdmVkIEFqYXggc3VwcG9ydCwgUGFnZQ0KQWN0aW9uIHN1cHBvcnQgYW5kIGxpZ2h0LXdlaWdodCBzdGF0ZWZ1bCBjb250cm9scyB0byByZXBsYWNlIHN0YXRlZnVsIHBhZ2VzLg0KDQo8cD4mbmJzcDs8L3A+DQoNCjxoMj5DaGFuZ2VzPC9oMj4NCg0KPGRsPg0KICA8ZHQ+PGEgbmFtZT0iMi4zLjAiPjwvYT4NCiAgICAgIDxkaXYgY2xhc3M9InJlbGVhc2UtaGVhZGVyIj5MYXRlc3QgRGV2ZWxvcG1lbnQgUmVsZWFzZSAtIFZlcnNpb24gMi4zLjAgUmVsZWFzZSBDYW5kaWRhdGUgMSAtIDMwIEphbnVhcnkgMjAxMTwvZGl2Pg0KICA8L2R0Pg0KICA8ZGQ+DQogICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICA8Yj5JTVBPUlRBTlQ6PC9iPiBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzIuMy4wIj51cGdyYWRlIHBhdGg8L2E+DQogICAgICB3aGVuIHVwZ3JhZGluZyBmcm9tIHByZXZpb3VzIHJlbGVhc2VzLg0KICAgICAgPC9kaXY+DQogICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgICA8Yj5NYWpvciBuZXcgZmVhdHVyZXM8L2I+DQogICAgICA8L2Rpdj4NCiAgICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgICAgPGxpPg0KICAgICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0Lmh0bWwiPkFqYXg8L2E+IHN1cHBvcnQuDQogICAgICAgIDwvbGk+DQogICAgICAgIDxsaT4NCiAgICAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMwNy5odG1sIj5QYWdlIEFjdGlvbjwvYT4gc3VwcG9ydC4NCiAgICAgICAgPC9saT4NCiAgICAgICAgPGxpPg0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1N0YXRlZnVsLmh0bWwiPlN0YXRlZnVsPC9hPiBDb250cm9scy4NCiAgICAgICAgPC9saT4NCiAgICAgIDwvdWw+DQogICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgICA8Yj5OZXcgZG9jdW1lbnRhdGlvbjo8L2I+DQogICAgICA8L2Rpdj4NCiAgICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgICAgPGxpPg0KICAgICAgICAgIEFkZGVkIGEgc2VjdGlvbiBjb3ZlcmluZyB0aGUgbmV3DQogICAgICAgICAgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDNzMDguaHRtbCI+QmVoYXZpb3I8L2E+IHN1cHBvcnQuDQogICAgICAgIDwvbGk+DQogICAgICAgIDxsaT4NCiAgICAgICAgICBBZGRlZCBhIGNoYXB0ZXIgb24gPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDQuaHRtbCI+QWpheDwvYT4sDQogICAgICAgICAgY292ZXJpbmcgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDRzMDIuaHRtbCI+QWpheEJlaGF2aW9yczwvYT4sDQogICAgICAgICAgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDRzMDMuaHRtbCI+QWpheCBleGVjdXRpb24gZmxvdzwvYT4NCiAgICAgICAgICBhbmQgYSBmdWxsIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czA0Lmh0bWwiPmV4YW1wbGU8L2E+Lg0KICAgICAgICA8L2xpPg0KICAgICAgICA8bGk+DQogICAgICAgICAgQWRkZWQgYSBzZWN0aW9uIGNvdmVyaW5nIHRoZSBuZXcNCiAgICAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMwNy5odG1sIj5QYWdlIEFjdGlvbjwvYT4gc3VwcG9ydC4NCiAgICAgICAgPC9saT4NCiAgICAgIDwvdWw+DQogICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgPGI+TmV3IGV4YW1wbGVzOjwvYj4NCiAgICAgIDwvZGl2Pg0KICAgICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy8iPmV4YW1wbGVzPC9hPg0KICAgICAgICAgIHNob3djYXNpbmcgdGhlIG5ldyBBamF4IHN1cHBvcnQuIFNlZSB0aGUgQWpheCBNZW51IGZvciB0aGUgZnVsbCBsaXN0DQogICAgICAgICAgb2YgZXhhbXBsZXMuDQogICAgICAgIDwvbGk+DQogICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBhbiBleGFtcGxlIHNob3dpbmcgaG93IHRvIGludGVncmF0ZSBhIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvcGFuZWwvdGFiYmVkLXBhbmVsLXdpdGgtY29udHJvbHMuaHRtIj5UYWJiZWRQYW5lbCwgRm9ybSBhbmQgVGFibGU8L2E+Lg0KICAgICAgICA8L2xpPg0KICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgYW4gZXhhbXBsZSBzaG93aW5nIGEgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9wYW5lbC9zdGF0ZWZ1bC10YWJiZWQtcGFuZWwtZGVtby5odG0iPlN0YXRlZnVsIFRhYmJlZFBhbmVsPC9hPi4NCiAgICAgICAgPC9saT4NCiAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIGFuIGV4YW1wbGUgRmllbGRTZXBhcmF0b3IgQ29udHJvbCBhbmQgZXhhbXBsZSB1c2FnZSBwYWdlDQogICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NDQiPkNMSy01NDQ8L2E+XS4NCiAgICAgICAgPC9saT4NCiAgICAgIDwvdWw+DQogICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgICA8Yj5SZW1vdmVkOjwvYj4NCiAgICAgIDwvZGl2Pg0KICAgICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgUmVtb3ZlZCB0aGUgYWJpbGl0eSB0byBhdXRvbWF0aWNhbGx5IDx0dD5ieXBhc3MgdmFsaWRhdGlvbjwvdHQ+IGZvcg0KICAgICAgICAgIEZvcm1zIHRocm91Z2ggSmF2YVNjcmlwdC4gVGhpcyBhYmlsaXR5IHdhcyBhZGRlZCBpbiAyLjIuMCBidXQgcmFpc2VkDQogICAgICAgICAgY29uY2VybnMgb3ZlciBzZWN1cml0eSBhbmQgd2FzIGRyb3BwZWQgZm9yIDIuMy4wLiBJZiB5b3UgdXNlZCB0aGlzDQogICAgICAgICAgZmVhdHVyZSBpbiBleGlzdGluZyBhcHBsaWNhdGlvbnMsIHBsZWFzZSBzZWUgdGhlDQogICAgICAgICAgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjcmVtb3ZlZC1ieXBhc3MtdmFsaWRhdGlvbiI+VXBncmFkZSBwYXRoPC9hPg0KICAgICAgICAgIGZvciBhIHNhZmUgYWx0ZXJuYXRpdmUgdG8gPHR0PmJ5cGFzcyB2YWxpZGF0aW9uPC90dD4uIFdlIGFwb2xvZ2l6ZSBmb3INCiAgICAgICAgICB0aGUgaW5jb252ZW5pZW5jZS4NCiAgICAgICAgICA8cC8+DQogICAgICAgIDwvbGk+DQogICAgICA8L3VsPg0KICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgICAgPGI+RGVwcmVjYXRlZDo8L2I+DQogICAgICA8L2Rpdj4NCiAgICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIERlcHJlY2F0ZWQgc3RhdGVmdWwgcGFnZSBzdXBwb3J0OiA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0U3RhdGVmdWwoYm9vbGVhbikiPlBhZ2Uuc2V0U3RhdGVmdWwoKTwvYT4uDQogICAgICAgICAgPHAvPg0KICAgICAgICAgIFN0YXRlZnVsIHBhZ2VzIGhhZCB0aGUgZm9sbG93aW5nIGlzc3VlczoNCiAgICAgICAgICA8dWw+DQogICAgICAgICAgICA8bGk+DQogICAgICAgICAgICBTdGF0ZWZ1bCBwYWdlcyB3YXMgaW50cm9kdWNlZCB0byBtYWtlIGl0IGVhc2llciB0byBzdG9yZSBwYWdlIHN0YXRlIGFjcm9zcw0KICAgICAgICAgICAgbXVsdGlwbGUgSFRUUCByZXF1ZXN0cy4gSG93ZXZlciBkZXZlbG9waW5nIGEgc3RhdGVmdWwgcGFnZSBpcyB2ZXJ5IGRpZmZlcmVudA0KICAgICAgICAgICAgZnJvbSBkZXZlbG9waW5nIGEgc3RhdGVsZXNzIG9uZSBhbmQgdGhpcyBsZWFkIHRvIENsaWNrIGFwcGxpY2F0aW9ucyB0aGF0IGFyZQ0KICAgICAgICAgICAgaW5jb25zaXN0ZW50IGFuZCBoYXJkZXIgdG8gbWFpbnRhaW4uDQogICAgICAgICAgICA8L2xpPg0KICAgICAgICAgICAgPGxpPg0KICAgICAgICAgICAgSW4gYWRkaXRpb24gc3RhdGVmdWwgcGFnZSBzdXBwb3J0IGhhcyBuZXZlciBiZWVuIGltcGxlbWVudGVkIGNvbnNpc3RlbnRseQ0KICAgICAgICAgICAgYWNyb3NzIHRoZSBmcmFtZXdvcmsgYW5kIHNvbWUgY29tcG9uZW50cyBkaWQgbm90IHdvcmsgY29ycmVjdGx5Lg0KICAgICAgICAgICAgPC9saT4NCiAgICAgICAgICAgIDxsaT4NCiAgICAgICAgICAgIFN0YXRlZnVsIHBhZ2VzIGFyZSB2ZXJ5IGNvYXJzZSBncmFpbmVkLCBtYWtpbmcgaXQgZGlmZmljdWx0IHRvIGNvbnRyb2wNCiAgICAgICAgICAgIHdoaWNoIG9iamVjdHMgYXJlIHN0b3JlZCBpbiB0aGUgc2Vzc2lvbi4NCiAgICAgICAgICAgIDwvbGk+DQogICAgICAgICAgICA8bGk+DQogICAgICAgICAgICBTdGF0ZWZ1bCBwYWdlcyBoYXZlIGFsc28gaW50cm9kdWNlZCB1bm5lY2Vzc2FyeSBjb21wbGV4aXR5IGluIHRoZSBmcmFtZXdvcmsNCiAgICAgICAgICAgIGl0c2VsZiwgd2hpY2ggY2FuIG5vdyBiZSBwaGFzZWQgb3V0Lg0KICAgICAgICAgICAgPC9saT4NCiAgICAgICAgICA8L3VsPg0KICAgICAgICAgIFVuZm9ydHVuYXRlbHkgdGhlcmUgaXMgbm8gZGlyZWN0IHVwZ3JhZGUgcGF0aCBmcm9tIGEgc3RhdGVmdWwgcGFnZS4NCiAgICAgICAgICBIb3dldmVyIHRoZSBtYWpvcml0eSBvZiB1c2UgY2FzZXMgYXJlIGNhdGVyZWQgZm9yIGJ5IHRoZSBuZXcgc3RhdGVmdWwNCiAgICAgICAgICBzdXBwb3J0IGluIHRoZSBjb250cm9sczogVGFibGUsIEZvcm0sIFRhYmJlZFBhbmVsLCBGaWVsZCBhbmQgQWJzdHJhY3RMaW5rLg0KICAgICAgICA8L2xpPg0KICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+RGVwcmVjYXRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZU5vZGUuaHRtbCNUcmVlTm9kZShqYXZhLmxhbmcuT2JqZWN0LCBqYXZhLmxhbmcuU3RyaW5nLCBvcmcuYXBhY2hlLmNsaWNrLmV4dHJhcy50cmVlLlRyZWVOb2RlKSI+VHJlZU5vZGUgY29uc3RydWN0b3JzPC9hPg0KICAgICAgICAgICAgd2hpY2ggYWNjZXB0cyBhIHBhcmVudCBub2RlLiBJbnN0ZWFkIHVzZQ0KICAgICAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL1RyZWVOb2RlLmh0bWwjYWRkKG9yZy5hcGFjaGUuY2xpY2suZXh0cmFzLnRyZWUuVHJlZU5vZGUpIj5hZGQ8L2E+DQogICAgICAgICAgICB0byBidWlsZCB0aGUgbm9kZSBoaWVyYXJjaHkNCiAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzQzIj5DTEstNzQzPC9hPl0uDQogICAgICAgIDwvbGk+DQogICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5EZXByZWNhdGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQWN0aW9uTGlzdGVuZXJBZGFwdG9yLmh0bWwiPkFjdGlvbkxpc3RlbmVyQWRhcHRvcjwvYT4NCiAgICAgICAgICAgIHNpbmNlIEFjdGlvbkxpc3RlbmVyIG9ubHkgaGFzIGEgc2luZ2xlIG1ldGhvZCBhbmQgbm8gYWRhcHRvciBpcyBuZWNlc3NhcnkNCiAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzMxIj5DTEstNzMxPC9hPl0uDQogICAgICAgIDwvbGk+DQogICAgICA8L3VsPg0KICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgICAgPGI+TmV3IGZlYXR1cmVzIGFuZCBpc3N1ZXMgcmVzb2x2ZWQ6PC9iPg0KICAgICAgPC9kaXY+DQogICAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtO21hcmdpbi1ib3R0b206IDJlbSI+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBJbXByb3ZlIGZpZWxkcyB0byBvbmx5IGJlIHByb2Nlc3NlZCBpZiB0aGV5IGhhdmUgYW4gaW5jb21pbmcgcmVxdWVzdA0KICAgICAgICAgICAgICBwYXJhbWV0ZXIuIFRoaXMgaW1wcm92ZW1lbnQgc3RyZWFtbGluZXMgZHluYW1pYyBmb3JtcyBzaW5jZSBmaWVsZHMNCiAgICAgICAgICAgICAgYWRkZWQgYXQgcnVudGltZSBkdXJpbmcgcyBQT1NUIHJlcXVlc3Qgd29uJ3QgYmluZCB0aGVpciB2YWx1ZXMgYW5kDQogICAgICAgICAgICAgIHdvbid0IGJlIHZhbGlkYXRlZCBmb3IgdGhhdCByZXF1ZXN0LiBJbiBzdWJzZXF1ZW50IHJlcXVlc3RzIHRoZSBGaWVsZA0KICAgICAgICAgICAgICB3aWxsIGhhdmUgYW4gaW5jb21pbmcgcGFyYW1ldGVyIGFuZCBzbyB3aWxsIGhhdmUgaXQncyB2YWx1ZSBib3VuZCBhbmQNCiAgICAgICAgICAgICAgdmFsaWRhdGVkLiBBbm90aGVyIGFkdmFudGFnZSBpcyB0aGF0IGR5bmFtaWNhbGx5IGFkZGVkIEZpZWxkcyB3b24ndA0KICAgICAgICAgICAgICBoYXZlIHRoZWlyIGRlZmF1bHQgdmFsdWUgb3ZlcnJpZGRlbiBpbiB0aGUgUE9TVCByZXF1ZXN0IHRoZXkgd2VyZSBhZGRlZCBpbi4NCiAgICAgICAgICAgICAgVGhpcyBpc3N1ZSBoYXMgYmVlbiByYWlzZWQgYnkgTmlybWFsIFNvbGFua2kNCiAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzIyIj5DTEstNzIyPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICBBZGRlZCBhdXRvbWFwcGluZyBzdXBwb3J0IGZvciBHQUUgd2l0aCBhIGNhdmVhdCB0aGF0IHBhZ2UgdGVtcGxhdGVzDQogICAgICAgICAgICBtdXN0IGJlIHBsYWNlZCB1bmRlciB0aGUgZm9sZGVycyA8dHQ+cGFnZTwvdHQ+IG9yIDx0dD5wYWdlczwvdHQ+Lg0KICAgICAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEtlIFN1bg0KICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MzkiPkNMSy02Mzk8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgIEFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvTWVzc2FnZXNNYXBTZXJ2aWNlLmh0bWwiPk1lc3NhZ2VzTWFwU2VydmljZTwvYT4NCiAgICAgICAgICAgIGludGVyZmFjZSB0byBzdXBwb3J0IHBsdWdnYWJsZSBtZXNzYWdlcyBtYXAgaW1wbGVtZW50YXRpb25zDQogICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY1NSI+Q0xLLTY1NTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgSW1wcm92ZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9NZXNzYWdlc01hcC5odG1sIj5NZXNzYWdlc01hcDwvYT4NCiAgICAgICAgICAgIHRvIGJlIGV4dGVuZGFibGUgYW5kIGN1c3RvbWl6YWJsZQ0KICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MjgiPkNMSy03Mjg8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIGxvYWRpbmcgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0RhdGVGaWVsZC5odG1sIj5EYXRlRmllbGQ8L2E+DQogICAgICAgICAgICB0cmFuc2xhdGlvbnMgZm9yIG1vbnRoIGFuZCBkYXkgbmFtZXMgZnJvbSB0aGUgSkRLLg0KICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NTAiPkNMSy02NTA8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgTWVudXMgdGhhdCBkbyBub3QgaGF2ZSA8dHQ+cm9sZXM8L3R0PiBkZWZpbmVkLg0KICAgICAgICAgICAgICBJZiBubyByb2xlcyBhcmUgZGVmaW5lZCwNCiAgICAgICAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCNpc1VzZXJJblJvbGVzKCkiPklzVXNlckluUm9sZXM8L2E+DQogICAgICAgICAgICAgIHBhc3NlcyBhIDx0dD5udWxsPC90dD4gYXJndW1lbnQgdG8NCiAgICAgICAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9zZWN1cml0eS9BY2Nlc3NDb250cm9sbGVyLmh0bWwjaGFzQWNjZXNzKGphdmF4LnNlcnZsZXQuaHR0cC5IdHRwU2VydmxldFJlcXVlc3QsIGphdmEubGFuZy5TdHJpbmcpIj5oYXNBY2Nlc3M8L2E+DQogICAgICAgICAgICAgIHRvIGRldGVybWluZSB3aGV0aGVyIGFjY2VzcyBpcyBwZXJtaXR0ZWQgdG8gbWVudXMgd2l0aG91dCByb2xlcw0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcyNCI+Q0xLLTcyNDwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBQb2xpc2ggbGFuZ3VhZ2Ugc3VwcG9ydC4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBUb21hc3ogQmFuZHVyYQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTczOSI+NzM5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgQ2hhbmdlZCBBYnN0cmFjdENvbnRyb2wgbm90IHRvIHJlbmRlciB0aGUgPHR0Pm5hbWU8L3R0Pg0KICAgICAgICAgICAgICBhdHRyaWJ1dGUgc2luY2UgaXQgaXMgb25seSB1c2VkIGZvciBGaWVsZCBjb250cm9scw0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY5OSI+Q0xLLTY5OTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBJbXByb3ZlZCBUYWJsZSBhbmQgU2VsZWN0IHRvIHJldHJpZXZlIGRhdGEgZnJvbSB0aGVpciBEYXRhUHJvdmlkZXJzDQogICAgICAgICAgICAgIGR1cmluZyB0aGUgb25SZW5kZXIgZXZlbnQuIFRoaXMgY2hhbmdlIGFsbG93cyBleGNlcHRpb25zIHRocm93bg0KICAgICAgICAgICAgICBieSBEYXRhUHJvdmlkZXJzIHRvIGJlIGhhbmRsZWQgYnkgdGhlIEVycm9yUGFnZQ0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY4NCI+Q0xLLTY4NDwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBJbXByb3ZlZCBEYXRlRmllbGQgdG8gbG9hZCB0aGUgPHR0PmRhdGUtZm9ybWF0LXBhdHRlcm48L3R0PiBvbiBkZW1hbmQuDQogICAgICAgICAgICAgIFRoaXMgY2hhbmdlIGFsbG93cyBvbmUgdG8gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgPHR0PmRhdGUtZm9ybWF0LXBhdHRlcm48L3R0Pg0KICAgICAgICAgICAgICBmcm9tIHRoZSBwYWdlIHByb3BlcnRpZXMgZmlsZTogPHR0PmNsaWNrLXBhZ2UucHJvcGVydGllczwvdHQ+Lg0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcwNSI+Q0xLLTcwNTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBhYnNvbHV0ZSBwYWdlIGNsYXNzbmFtZXMgd2hlbiBjb25maWd1cmluZyBwYWdlcw0KICAgICAgICAgICAgICBpbiA8dHQ+Y2xpY2sueG1sPC90dD4uIEFic29sdXRlIGNsYXNzbmFtZXMgYWlkcyB3aXRoIElERSBob3QtbGlua2luZw0KICAgICAgICAgICAgICBhbmQgaXMgbGVzcyBjb25mdXNpbmcgdG8gdXNlLg0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcwNCI+Q0xLLTcwNDwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBBZGRlZCBhIHJlbmRlcklkIHByb3BlcnR5IHRvIFJlc291cmNlRWxlbWVudCB0byBleGNsdWRlIHRoZSBJRCBhdHRyaWJ1dGUgZnJvbSByZW5kZXJpbmcNCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02OTUiPkNMSy02OTU8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgSW1wcm92ZWQgQ291bnRyeVNlbGVjdCB0byBpbmNsdWRlIG1vcmUgY291bnRyaWVzIGJ5IHVzaW5nIExvY2FsZS5nZXRJU09Db3VudHJpZXMoKS4NCiAgICAgICAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBMb3JlbnpvIFNpbWlvbmF0bw0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc0MCI+Q0xLLTc0MDwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCBDb250cm9sIElEcyB0byByZW5kZXIgdW5kZXJzY29yZXMgaW5zdGVhZCBvZiBwZXJpb2RzDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzQ3Ij5DTEstNzQ3PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIFRhYmJlZEZvcm0gYW5kIENheWVubmVUYWJiZWRGb3JtIEphdmFTY3JpcHQgdmFsaWRhdGlvbi4gVGhpcw0KICAgICAgICAgICAgICBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBUb21hc3ogQmFuZHVyYQ0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTczNSI+Q0xLLTczNTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCBlc2NhcGluZyBvZiBjb250cm9sIHZhbHVlcyBhbmQgYXR0cmlidXRlcyB0byBiZSBYTUwgZnJpZW5kbHkNCiAgICAgICAgICAgICAgaW4gb3JkZXIgdG8gc3VwcG9ydCBBamF4IHJlcXVlc3RzLiBQcmV2aW91c2x5IGFsbCBIVE1MIGNoYXJhY3RlcnMgd2FzIGVzY2FwZWQsDQogICAgICAgICAgICAgIG5vdyBvbmx5IHRoZSBmb2xsb3dpbmcgY2hhcmFjdGVycyBhcmUgZXNjYXBlZDogJmx0OywgJmd0OywgJnF1b3Q7LCAmIzAzOTssICZhbXA7DQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjc0Ij5DTEstNjc0PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEFkZGVkIG1ldGhvZCwgQ2xpY2tVdGlscy5lc2NhcGUoU3RyaW5nKSwgdG8gZXNjYXBlIFhNTCBjaGFyYWN0ZXJzLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBJbXByb3ZlZCBDbGlja1V0aWxzLmVuY29kZVVybCB0byBkZWZhdWx0IHRvICJVVEYtOCIgaWYgbm8gcmVxdWVzdA0KICAgICAgICAgICAgICBjaGFyYWN0ZXIgZW5jb2RpbmcgaXMgYXZhaWxhYmxlDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzIwIj5DTEstNzIwPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEltcHJvdmVkIHBhZ2UgaGVhZGVyIHN1cHBvcnQgYWxsb3dpbmcgaGVhZGVycyB0byBiZSBzZXQgZnJvbSBwYWdlIGNvbnN0cnVjdG9yDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzExIj5DTEstNzExPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIFRhYmxlIGNvbnRyb2xMaW5rIHdoaWNoIGRpZCBub3Qga2VlcCBhIHJlZmVyZW5jZSB0byBpdHMgcGFyZW50DQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjg2Ij5DTEstNjg2PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIENvbmN1cnJlbnRNb2RpZmljYXRpb25FeGNlcHRpb24gd2hlbiByZW5kZXJpbmcgY2FjaGVkIE1lbnVzDQogICAgICAgICAgICAgIGZyb20gbXVsdGlwbGUgdGhyZWFkcw0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcxMiI+Q0xLLTcxMjwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCByYWNlIGNvbmRpdGlvbiB3aGlsZSBpbml0aWFsaXppbmcgY2FjaGVkIG1lbnVzDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzEzIj5DTEstNzEzPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIG1lbnUgbm90IHJlbmRlcmluZyBzZXBhcmF0b3INCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02ODEiPkNMSy02ODE8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgU3VibWl0TGluayB0byB1c2UgRm9ybSBpZCBpbnN0ZWFkIG9mIEZvcm0gbmFtZQ0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcwMSI+Q0xLLTcwMTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCBGb3JtIHZhbGlkYXRpb24gdG8gYWRkIGFuZCByZW1vdmUgYW4gPHR0PmVycm9yPC90dD4gY2xhc3MNCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MDAiPkNMSy03MDA8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgaXNzdWUgd2hlcmUgQ29udGV4dC5jcmVhdGVQYWdlIGNvdWxkIGxlYWQgdG8gZHVwbGljYXRlIHBhZ2UtdG8tY2xhc3MNCiAgICAgICAgICAgICAgbWFwcGluZ3MuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBbmRyZXkgUnliaW4gYW5kIGZpeGVkIGJ5IE1kLiBKYWhpZCBTaG9oZWwNCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MjUiPkNMSy02MjU8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgQXV0b0NvbXBsZXRlVGV4dEZpZWxkIG5vdCB0byBiZSBhZGRlZCB0byBwYXJlbnQgUGFnZQ0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcwNyI+Q0xLLTcwNzwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgRml4ZWQgYSBwb3RlbnRpYWwgbWVtb3J5IGxlYWsgd2hlbiB1bmRlcGxveWluZyBhIGNsaWNrIGFwcGxpY2F0aW9uLg0KICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MDYiPkNMSy03MDY8L2E+XS4NCiAgICAgICAgIDwvbGk+DQogICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIGlzc3VlIHdoZXJlIHNldHRpbmcgPHR0PmF1dG9iaW5kaW5nPSJkZWZhdWx0IjwvdHQ+IHRocm93cyBleGNlcHRpb24uDQogICAgICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBUc2F5IFlhdyBIYW5uDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzE0Ij5DTEstNzE0PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIFNlbGVjdCB0byBzZXQgYW4gaW5pdGlhbCB2YWx1ZSB3aGVuIHBvcHVsYXRlZCB0aHJvdWdoIGENCiAgICAgICAgICAgICAgRGF0YVByb3ZpZGVyLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFNhbmRlciB2YW4gR3JpZWtlbg0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc0NSI+Q0xLLTc0NTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KRml4ZWQgdGFibGUgaGVhZGVycyB0aGF0IHVzZWQgaW5jb3JyZWN0IHRpdGxlIGF0dHJpYnV0ZSB3aGVuIHRhYmxlIGlzIHNvcnRhYmxlLg0KICAgICAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUGF0cmljayBUYWxib3QNCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNDEiPkNMSy0yNDE8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgQ2F5ZW5uZVRlbXBsYXRlIGdlbmVyaWNzIHRvIGFsaWduIHdpdGggQ2F5ZW5uZSBEYXRhQ29udGV4dA0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc1MCI+Q0xLLTc1MDwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCByZWFkb25seSBDaGVja0xpc3QgdG8gdXNlIDx0dD5kaXNhYmxlZDwvdHQ+IGF0dHJpYnV0ZSwgDQogICAgICAgICAgICAgIHNhbWUgYXMgQ2hlY2tib3ggZG9lcyBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc1MSI+Q0xLLTc1MTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBSZW1vdmVkIHRoZSA8dHQ+I0ZJWEVEPC90dD4gYXR0cmlidXRlcyBmcm9tIHRoZSA8dHQ+Y2xpY2suZHRkPC90dD4NCiAgICAgICAgICAgICAgd2hpY2ggY2F1c2VkIHhtbCB2YWxpZGF0aW9uIGVycm9ycy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFJ5YW4gSG9sbWVzDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzE3Ij5DTEstNzE3PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgVXBkYXRlZCBWZWxvY2l0eSBsaWJyYXJ5IHRvIHZlcnNpb24gMS43IFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzQ4Ij5DTEstNzQ4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgVXBkYXRlIHRvIHRoZSBsYXRlc3QgdmVyc2lvbiBmb3Igc29tZSBvZiB0aGUgSkFScyBkZXBlbmRlbmNpZXM6IGxvZzRqLTEuMi4xNiwgZnJlZW1hcmtlci0yLjMuMTYsDQogICAgICAgICAgICAgIGNvbW1vbnMtY29kZWMtMS40LCBhbmQgY29tbW9ucy1sYW5nLTIuNS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgVXBkYXRlIHRvIFZlbG9jaXR5IFRvb2xzIDIuMCBXZWJhcHBSZXNvdXJjZUxvYWRlcg0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY5MyI+Q0xLLTY5MzwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBSZXBsYWNlIEVEVS5vc3dlZ28uY3MuZGwudXRpbC5jb25jdXJyZW50LkNvbmN1cnJlbnRSZWFkZXJIYXNoTWFwIHdpdGggamF2YS51dGlsLmNvbmN1cnJlbnQuQ29uY3VycmVudEhhc2hNYXAuDQogICAgICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgSGVucnkgU2FwdXRyYQ0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYzNiI+Q0xLLTYzNjwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBSZW1vdmVkIG9nbmwuT2dubE9wcyBkZXBlbmRlbmN5Lg0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY5NCI+Q0xLLTY5NDwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICA8L3VsPg0KICA8L2RkPg0KICA8ZHQ+PGEgbmFtZT0iMi4yLjAiPjwvYT4NCiAgICA8ZGl2IGNsYXNzPSJyZWxlYXNlLWhlYWRlciI+TGF0ZXN0IFN0YWJsZSBSZWxlYXNlIC0gVmVyc2lvbiAyLjIuMCAtIDIyIE1heSAyMDEwPC9kaXY+DQogIDwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICA8Yj5JTVBPUlRBTlQ6PC9iPiBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzIuMi4wIj51cGdyYWRlIHBhdGg8L2E+DQogICAgICB3aGVuIHVwZ3JhZGluZyBmcm9tIHByZXZpb3VzIHJlbGVhc2VzLg0KICAgICAgPHAvPg0KICAgICAgSXRzIHdvcnRoIGhpZ2hsaWdodGluZyB0aGF0IGluIHRoaXMgcmVsZWFzZSB3ZSBoYXZlIHJlbW92ZWQgdGhlIGRlcHJlY2F0ZWQgbWV0aG9kcw0KICAgICAgPHR0PlBhZ2UuZ2V0SHRtbEltcG9ydHM8L3R0PiBhbmQgPHR0PkNvbnRyb2wuZ2V0SHRtbEltcG9ydHM8L3R0Pi4gVXNlcnMNCiAgICAgIHdpbGwgaGF2ZSB0byBtaWdyYXRlIHRoZWlyIGNvZGUgdG8gdXNlIHRoZSBuZXcgPHR0PmdldEhlYWRFbGVtZW50czwvdHQ+IGluc3RlYWQuDQogICAgICBQbGVhc2Ugc2VlIHRoZSBzZWN0aW9uLCA8YSBocmVmPSJ1cGdyYWRlLXBhdGguaHRtbCNtaWdyYXRlLWltcG9ydHMiPm1pZ3JhdGluZyBpbXBvcnRzPC9hPiwNCiAgICAgIGZvciBtb3JlIGRldGFpbHMuDQogICAgPC9kaXY+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIDxiPk5ldyBleGFtcGxlczo8L2I+DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2Zvcm0vZHluYW1pYy9keW5hbWljLWZvcm0uaHRtIj4NCiAgICAgICAgRHluYW1pYyBGb3JtPC9hPiBkZW1vbnN0cmF0ZXMgaG93IHRvIGR5bmFtaWNhbGx5IGFkZCBuZXcgRmllbGRzIGF0IHJ1bnRpbWUuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2Zvcm0vZHluYW1pYy9keW5hbWljLWZpZWxkLXNldC5odG0iPg0KICAgICAgICBEeW5hbWljIEZpZWxkU2V0PC9hPiBkZW1vbnN0cmF0ZXMgaG93IHRvIGR5bmFtaWNhbGx5IGFkZCBhIEZpZWxkU2V0IGF0IHJ1bnRpbWUuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2Zvcm0vZHluYW1pYy9keW5hbWljLXNlbGVjdC5odG0iPg0KICAgICAgICBEeW5hbWljIFNlbGVjdDwvYT4gZGVtb25zdHJhdGVzIGhvdyB0byBkeW5hbWljYWxseSBhZGQgZmllbGRzIGJhc2VkIG9uIGEgU2VsZWN0IGZpZWxkIHZhbHVlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9jb250cm9sL2Rpc2FibGVkLWRlbW8uaHRtIj4NCiAgICAgICAgRGlzYWJsZWQgRGVtbzwvYT4gZGVtb25zdHJhdGVzIHRoZSBiZWhhdmlvciBvZiBkaXNhYmxlZCBmaWVsZHMuDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIDxiPk5ldyBmZWF0dXJlcyBhbmQgaXNzdWVzIHJlc29sdmVkOjwvYj4NCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtO21hcmdpbi1ib3R0b206IDJlbSI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2RhdGFwcm92aWRlci9EYXRhUHJvdmlkZXIuaHRtbCI+RGF0YVByb3ZpZGVyPC9hPg0KICAgICAgICBzdXBwb3J0IGZvciBUYWJsZSwgU2VsZWN0LCBQaWNrTGlzdCBhbmQgQ2hlY2tMaXN0IHByb3ZpZGluZw0KICAgICAgICBvbiBkZW1hbmQgbG9hZGluZyBvZiBkYXRhLiBXaXRoIERhdGFQcm92aWRlcnMsIHVzZXJzIHdvbid0IGhhdmUgdG8gYmUNCiAgICAgICAgY29uY2VybmVkIGFib3V0IHdoaWNoIHBhZ2UgZXZlbnQgKG9uSW5pdCBvciBvblJlbmRlcikgdG8gc2V0IHRoZSBkYXRhIG9uDQogICAgICAgIHRoZSBjb250cm9sDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjQwIj5DTEstNjQwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9kYXRhcHJvdmlkZXIvUGFnaW5nRGF0YVByb3ZpZGVyLmh0bWwiPlBhZ2luZ0RhdGFQcm92aWRlcjwvYT4NCiAgICAgICAgaW50ZXJmYWNlIHRvIHN1cHBvcnQgbGFyZ2UgcGFnaW5hdGVkIHJlc3VsdCBzZXRzIGZvciBUYWJsZXMNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NDAiPkNMSy02NDA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGEgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnVGYWN0b3J5Lmh0bWwiPk1lbnVGYWN0b3J5PC9hPg0KICAgICAgICBmb3IgY3JlYXRpbmcgYW5kIGxvYWRpbmcgTWVudXMgZnJvbSA8dHQ+Y29uZmlndXJhdGlvbjwvdHQ+IGZpbGVzLiBBbGwgdGhlDQogICAgICAgIHN0YXRpYyBNZW51IG1ldGhvZHMgaGF2ZSBiZWVuIGRlcHJlY2F0ZWQgYW5kIHdpbGwgYmUgcmVtb3ZlZCBpbiBhIGZ1dHVyZSByZWxlYXNlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgYW4gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnVGYWN0b3J5Lmh0bWwjZ2V0Um9vdE1lbnUoYm9vbGVhbikiPm9wdGlvbjwvYT4NCiAgICAgICAgZm9yIE1lbnVGYWN0b3J5IHRvIG5vdCBzdGF0aWNhbGx5IGNhY2hlIG1lbnVzLiBUaGlzIGFsbG93cw0KICAgICAgICBkZXZlbG9wZXJzIHRvIGNhY2hlIG1lbnVzIGluIGRpZmZlcmVudCBzY29wZXMgc3VjaCBhcyBIdHRwU2Vzc2lvbi4NCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MDUiPkNMSy00MDU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGkxOG4gc3VwcG9ydCBmb3IgTWVudXMgbG9hZGVkIGZyb20gPHR0Pm1lbnUueG1sPC90dD4uIFRoZSBtZW51DQogICAgICAgIERURCBub3cgaW5jbHVkZXMgYSBuZXcgPHR0Pm5hbWU8L3R0PiBhdHRyaWJ1dGUuIEJ5IHNwZWNpZnlpbmcNCiAgICAgICAgYSA8dHQ+bmFtZTwvdHQ+IGF0dHJpYnV0ZSBpbiA8dHQ+bWVudS54bWw8L3R0PiwgdGhlIE1lbnUgd2lsbCBhdHRlbXB0IHRvDQogICAgICAgIGxvYWQgaXRzIDx0dD5sYWJlbDwvdHQ+IGFuZCA8dHQ+dGl0bGU8L3R0PiBmcm9tIHJlc291cmNlIGJ1bmRsZXMNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01OTEiPkNMSy01OTE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGEgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZUludGVyY2VwdG9yLmh0bWwiPlBhZ2UgSW50ZXJjZXB0b3I8L2E+DQogICAgICAgIGZhY2lsaXR5IHRoYXQgcHJvdmlkZXMgYW4gZXh0ZW5zaW9uIHBvaW50IGZvciBjb2RlIHdoaWNoIGNhbiBsaXN0ZW4gdG8NCiAgICAgICAga2V5IHBhZ2UgZXZlbnRzIGFuZCBhbHNvIGludGVycnVwdCBub3JtYWwgcGFnZSBwcm9jZXNzaW5nIGZsb3cuDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTk4Ij5DTEstNTk4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBpbXByb3ZlZCBkeW5hbWljIEZvcm0gc3VwcG9ydC4gRm9ybXMgY2FuIG5vdyBvcHRpb25hbGx5IGJ5cGFzcw0KICAgICAgICB2YWxpZGF0aW9uIGZvciBKYXZhU2NyaXB0IGJhc2VkIHN1Ym1pc3Npb25zIHVzaW5nIHRoZSBuZXcgSmF2YVNjcmlwdA0KICAgICAgICBmdW5jdGlvbiA8dHQ+IkNsaWNrLnN1Ym1pdChmb3JtLCB2YWxpZGF0ZSkiPC90dD4NCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MzgiPkNMSy02Mzg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGltcHJvdmVkIGR5bmFtaWMgUGFnZSBhbmQgRm9ybSBiZWhhdmlvdXIgdGhyb3VnaCBuZXcgaGVscGVyIG1ldGhvZHMNCiAgICAgICAgdGhhdCBjYW4gYmluZCBhbmQgdmFsaWRhdGUgRm9ybXMgYW5kIEZpZWxkcyA8dHQ+YmVmb3JlPC90dD4gdGhlIG9uUHJvY2Vzcw0KICAgICAgICBwYWdlIGV2ZW50IGUuZy4gaW4gdGhlIFBhZ2UgY29uc3RydWN0b3Igb3IgPHR0PiJvbkluaXQiPC90dD4gZXZlbnQuDQogICAgICAgIFRoZSBuZXcgbWV0aG9kcyBhcmU6DQogICAgICAgIDx1bCBzdHlsZT0ibWFyZ2luLXRvcDogMTBweDsiPg0KICAgICAgICAgICAgPGxpPg0KICAgICAgICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sI2JpbmQob3JnLmFwYWNoZS5jbGljay5jb250cm9sLkZpZWxkKSI+Q2xpY2tVdGlscy5iaW5kKEZpZWxkKTwvYT4NCiAgICAgICAgICAgIDwvbGk+DQogICAgICAgICAgICA8bGk+DQogICAgICAgICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwjYmluZChvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuRm9ybSkiPkNsaWNrVXRpbHMuYmluZChGb3JtKTwvYT4NCiAgICAgICAgICAgIDwvbGk+DQogICAgICAgICAgICA8bGk+DQogICAgICAgICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwjYmluZChvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuQWJzdHJhY3RMaW5rKSI+Q2xpY2tVdGlscy5iaW5kKEFic3RyYWN0TGluayk8L2E+DQogICAgICAgICAgICA8L2xpPg0KICAgICAgICAgICAgPGxpPg0KICAgICAgICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sI2JpbmRBbmRWYWxpZGF0ZShvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuRmllbGQpIj5DbGlja1V0aWxzLmJpbmRBbmRWYWxpZGF0ZShGaWVsZCk8L2E+DQogICAgICAgICAgICA8L2xpPg0KICAgICAgICAgICAgPGxpPg0KICAgICAgICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sI2JpbmRBbmRWYWxpZGF0ZShvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuRm9ybSkiPkNsaWNrVXRpbHMuYmluZEFuZFZhbGlkYXRlKEZvcm0pPC9hPg0KICAgICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjM4Ij5DTEstNjM4PC9hPl0NCiAgICAgICAgICAgIDwvbGk+DQogICAgICAgIDwvdWw+DQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBpbXByb3ZlZCBkaXNhYmxlZCBiZWhhdmlvciB0aHJvdWdoIHRoZSBmb2xsb3dpbmcgY2hhbmdlczoNCiAgICAgICAgPHVsIHN0eWxlPSJtYXJnaW4tdG9wOjEwcHgiPg0KICAgICAgICAgICAgPGxpPg0KICAgICAgICAgICAgICAgIERpc2FibGVkIGZpZWxkcyBhcmUgbm90IHByb2Nlc3NlZCBvciB2YWxpZGF0ZWQNCiAgICAgICAgICAgIDwvbGk+DQogICAgICAgICAgICA8bGk+DQogICAgICAgICAgICAgICAgRGlzYWJsZWQgZmllbGQgdmFsdWVzIGFyZSBub3QgY29waWVkIHRvIGRvbWFpbiBvYmplY3RzDQogICAgICAgICAgICA8L2xpPg0KICAgICAgICAgICAgPGxpPg0KICAgICAgICAgICAgICAgIERpc2FibGVkIGZpZWxkcyBhcmUgYXV0b21hdGljYWxseSBlbmFibGVkIGlmIHRoZSBmaWVsZCBoYXMgYW4NCiAgICAgICAgICAgICAgICBpbmNvbWluZyByZXF1ZXN0IHBhcmFtZXRlciwgaW5kaWNhdGluZyB0aGF0IHRoZSBmaWVsZCB3YXMgZW5hYmxlZA0KICAgICAgICAgICAgICAgIG9uIHRoZSBjbGllbnQgdXNpbmcgSmF2YVNjcmlwdC4gUGxlYXNlIG5vdGUgdGhhdCB0aGlzIGJlaGF2aW9yIGRvZXMNCiAgICAgICAgICAgICAgICBub3QgYXBwbHkgdG8gQ2hlY2tib3ggb3IgUmFkaW8gZmllbGRzLiBTZWUgdGhlDQogICAgICAgICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI3NldERpc2FibGVkKGJvb2xlYW4pIj5zZXREaXNhYmxlZCgpPC9hPg0KICAgICAgICAgICAgICAgIGphdmFkb2MgZm9yIGRldGFpbHMgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NDYiPkNMSy02NDY8L2E+XS4NCiAgICAgICAgICAgIDwvbGk+DQogICAgICAgIDwvdWw+DQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBuZXcgbWV0aG9kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQ29udGFpbmVyLmh0bWwjcmVwbGFjZShvcmcuYXBhY2hlLmNsaWNrLkNvbnRyb2wsIG9yZy5hcGFjaGUuY2xpY2suQ29udHJvbCkiPkNvbnRhaW5lci5yZXBsYWNlPC9hPg0KICAgICAgICBmb3IgcmVwbGFjaW5nIGFuIGV4aXN0aW5nIGNvbnRyb2wgd2l0aCBhIG5ldyBjb250cm9sLiBJbiBwcmV2aW91cyByZWxlYXNlcywNCiAgICAgICAgYW4gZXhjZXB0aW9uIHdvdWxkIGJlIHJhaXNlZCBpZiBhIHBhZ2Ugb3IgY29udGFpbmVyIGFscmVhZHkgY29udGFpbmVkIGENCiAgICAgICAgY29udHJvbCB3aXRoIHRoZSBzYW1lIG5hbWUgYXMgdGhlIG5ld2x5IGFkZGVkIGNvbnRyb2wuIEluIDIuMi4wIHRoZQ0KICAgICAgICByZXBsYWNlIG1ldGhvZCBpcyBhdXRvbWF0aWNhbGx5IGNhbGxlZCB3aGVuIGFkZGluZyBhIGNvbnRyb2wgd2hpY2ggbmFtZQ0KICAgICAgICBtYXRjaGVzIHRoYXQgb2YgYW4gZXhpc3RpbmcgY29udHJvbCBpbiB0aGUgcGFnZSBvciBjb250YWluZXIuIFRoaXMgYmVoYXZpb3INCiAgICAgICAgd2lsbCBsaWtlbHkgb25seSBiZW5lZml0IDx0dD5zdGF0ZWZ1bDwvdHQ+IHBhZ2VzIHNpbmNlIDx0dD5zdGF0ZWxlc3M8L3R0Pg0KICAgICAgICBwYWdlcyBhcmUgcmVjcmVhdGVkIGVhY2ggcmVxdWVzdA0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY2NiI+Q0xLLTY2NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbWV0aG9kcyB0byBGaWVsZHMgZm9yIHN0eWxpbmcgdGhlaXIgbGFiZWxzLiBTZWUgbmV3IG1ldGhvZHMNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI3NldExhYmVsU3R5bGUoamF2YS5sYW5nLlN0cmluZykiPkZpZWxkLnNldExhYmVsU3R5bGUoU3RyaW5nKTwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNzZXRMYWJlbFN0eWxlQ2xhc3MoamF2YS5sYW5nLlN0cmluZykiPkZpZWxkLnNldExhYmVsU3R5bGVDbGFzcyhTdHJpbmcpPC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFN0ZWZheA0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU5NSI+Q0xLLTU5NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbWV0aG9kcyB0byBGaWVsZHMgZm9yIHByb3ZpZGluZyBzdHlsaW5nIGhpbnRzIHRvIHRoZWlyDQogICAgICAgIGNvbnRhaW5pbmcgZWxlbWVudHMuIFNlZSBuZXcgbWV0aG9kcw0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwjc2V0UGFyZW50U3R5bGVIaW50KGphdmEubGFuZy5TdHJpbmcpIj5GaWVsZC5zZXRQYXJlbnRTdHlsZUhpbnQoU3RyaW5nKTwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNzZXRQYXJlbnRTdHlsZUNsYXNzSGludChqYXZhLmxhbmcuU3RyaW5nKSI+RmllbGQuc2V0UGFyZW50U3R5bGVDbGFzc0hpbnQoU3RyaW5nKTwvYT4uDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBTdGVmYXgNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01OTUiPkNMSy01OTU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHRyaW0gcHJvcGVydHkgdG8gRmllbGQgZm9yIGNvbnRyb2xsaW5nIGlmIHRoZSBGaWVsZCByZXF1ZXN0DQogICAgICAgIHBhcmFtZXRlciBpcyB0cmltbWVkIG9yIG5vdC4gU2VlIG5ldyBtZXRob2QNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI3NldFRyaW0oYm9vbGVhbikiPkZpZWxkLnNldFRyaW0oYm9vbGVhbik8L2E+Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQW5kcmV5IFJ5YmluDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjI3Ij5DTEstNjI3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBuZXcgQ29udGV4dCBtZXRob2RzDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNoYXNSZXF1ZXN0UGFyYW1ldGVyKGphdmEubGFuZy5TdHJpbmcpIj5Db250ZXh0Lmhhc1JlcXVlc3RQYXJhbWV0ZXIoU3RyaW5nKTwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNoYXNSZXF1ZXN0QXR0cmlidXRlKGphdmEubGFuZy5TdHJpbmcpIj5Db250ZXh0Lmhhc1JlcXVlc3RBdHRyaWJ1dGUoU3RyaW5nKTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBzdXBwb3J0IHRvIFNlbGVjdCBmb3IgYSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1NlbGVjdC5odG1sI3NldERlZmF1bHRPcHRpb24ob3JnLmFwYWNoZS5jbGljay5jb250cm9sLk9wdGlvbikiPmRlZmF1bHQgb3B0aW9uPC9hPg0KICAgICAgICB0aGF0IGNhbiBiZSB1c2VkIHRvIHZhbGlkYXRlIG5vbiBzZWxlY3Rpb24gYWdhaW5zdCBhbmQgYWxsb3dzIHRoZSBTZWxlY3QNCiAgICAgICAgdG8gb25seSBwb3B1bGF0ZSBpdHMgb3B0aW9uTGlzdCBhdCByZW5kZXJpbmcgdGltZSwgaW5zdGVhZCBvZiBkdXJpbmcNCiAgICAgICAgPHR0Pm9uUHJvY2VzczwvdHQ+IGV2ZW50Lg0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY0MSI+Q0xLLTY0MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgZGVmYXVsdCBhdXRvYmluZGluZyBtb2RlIHRvIGJpbmQgYm90aCBwdWJsaWMgZmllbGRzIGFuZCBmaWVsZHMNCiAgICAgICAgYW5ub3RhdGVkIHdpdGggQEJpbmRhYmxlLiBJbiBwcmV2aW91cyB2ZXJzaW9ucyB0aGUgZGVmYXVsdCBhdXRvYmluZGluZw0KICAgICAgICBtb2RlIG9ubHkgYmluZGVkIHB1YmxpYyBQYWdlIGZpZWxkcw0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY0OCI+Q0xLLTY0ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbW9jayBzdXBwb3J0IGZvciB1c2VyIDxhIGhyZWY9Im1vY2stYXBpL29yZy9hcGFjaGUvY2xpY2svc2VydmxldC9Nb2NrUHJpbmNpcGFsLmh0bWwiPnByaW5jaXBhbHM8L2E+DQogICAgICAgIGFuZCByb2xlcy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBTdmVuIFBmZWlmZmVyDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTg1Ij5DTEstNTg1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBsb2NhbGl6ZWQgRGF0ZSBmb3JtYXQgcGF0dGVybiBzdXBwb3J0LiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkNCiAgICAgICAgQW5kcmV5IFJ5YmluDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjEwIj5DTEstNjEwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBQb2xpc2ggcmVzb3VyY2UgYnVuZGxlIGZvciBEYXRlRmllbGQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQNCiAgICAgICAgZml4ZWQgYnkgUmFmYWwgUnVzaW4NCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MjQiPkNMSy02MjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIE1pZ3JhdGVkIGNvbnRyb2xzIHRvIGltcG9ydCByZXNvdXJjZXMgdGhyb3VnaCBFbGVtZW50cyBhbmQgdGhlDQogICAgICAgIDx0dD5nZXRIZWFkRWxlbWVudHM8L3R0PiBtZXRob2QNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NDciPkNMSy02NDc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIFNwcmluZ0NsaWNrU2VydmxldCB0byByZS1pbmplY3QgdHJhbnNpZW50IGJlYW5zIGFmdGVyIHN0YXRlZnVsDQogICAgICAgIHBhZ2UgZGVzZXJpYWxpemF0aW9uLiBUaGlzIGZlYXR1cmUgaXMgb25seSBzdXBwb3J0ZWQgd2hlbiB0aGUgc3RhdGVmdWwNCiAgICAgICAgcGFnZSBpbnN0YW5jZSBpcyBjcmVhdGVkIGJ5IENsaWNrLCBub3QgU3ByaW5nDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjY3Ij5DTEstNjY3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZXBsYWNlZCBQYWdlIGFuZCBDb250cm9sIGdldE1lc3NhZ2UgbWV0aG9kcyB3aXRoIHZhcmFyZ3MgZXF1aXZhbGVudHMNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MDQiPkNMSy02MDQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlbW92ZWQgQ2xpY2sgY29yZSdzIGRlcGVuZGVuY3kgb24gVmVsb2NpdHkuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBieSBBbmRyZXkgUnliaW4NCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MDYiPkNMSy02MDY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlcGxhY2VkIG11bHRpcGxlIENsaWNrVXRpbHMgY2xvc2UgbWV0aG9kcyB3aXRoIGEgc2luZ2xlIG1ldGhvZCBhY2NlcHRpbmcNCiAgICAgICAgYSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCNjbG9zZShqYXZhLmlvLkNsb3NlYWJsZSkiPkNsb3NlYWJsZTwvYT4uDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBbmRyZXkgUnliaW4NCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MjAiPkNMSy02MjA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIENsaWNrU2VydmxldCB0byB1c2UgdGhlIHJlc3BvbnNlJ3MgT3V0cHV0U3RyZWFtIGlmIHRoZSBXcml0ZXINCiAgICAgICAgY2Fubm90IGJlIHJldHJpZXZlZA0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY0NCI+Q0xLLTY0NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgaXNzdWUgd2hlcmUgUmFkaW9Hcm91cCBsYWJlbCByZWZlcmVuY2VkIGEgbm9uLWV4aXN0aW5nIElELiBSYWRpb0dyb3VwDQogICAgICAgIGlzIG5vdyB3cmFwcGVkIGluc2lkZSBhIHNwYW4gdGFnIHdpdGggdGhlIGdpdmVuIElELiBUaGlzIGlzc3VlIHdhcyByYWlzZWQNCiAgICAgICAgYW5kIGZpeGVkIGJ5IEZpbm4gQm9jaw0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU3NyI+Q0xLLTU3NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRGF0ZUZpZWxkIHRvIHNldCBzZWNvbmRzIGJhY2sgdG8gemVyby4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFuZHJleSBSeWJpbg0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY2NCI+Q0xLLTY2NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBUaGUgbWVudS5kdGQgaGFzIGJlZW4gcHVibGlzaGVkIHRvDQogICAgICAgICAgPGEgaHJlZj0iaHR0cDovL2NsaWNrLmFwYWNoZS5vcmcvZHRkcy9tZW51LTIuMi5kdGQiPmh0dHA6Ly9jbGljay5hcGFjaGUub3JnL2R0ZHMvbWVudS0yLjIuZHRkPC9hPi4NCiAgICAgICAgICBJZiB5b3Ugd2FudCB5b3VyIGNvbmZpZ3VyYXRpb24gdG8gY29uZm9ybSB0byB0aGUgbWVudS5kdGQsIGluY2x1ZGUNCiAgICAgICAgICB0aGUgZm9sbG93aW5nIGRlY2xhcmF0aW9uIGluIHlvdXIgbWVudS54bWw6DQogICAgICAgICAgPHByZSBjbGFzcz0icHJldHR5cHJpbnQiPiZsdDshRE9DVFlQRSBtZW51IFBVQkxJQw0KICAgICAgICItLy9BcGFjaGUgU29mdHdhcmUgRm91bmRhdGlvbi8vRFREIENsaWNrIE1lbnUgMi4yLy9FTiINCiAgICAgICAiaHR0cDovL2NsaWNrLmFwYWNoZS5vcmcvZHRkcy9tZW51LTIuMi5kdGQiJmd0OyA8L3ByZT4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgVGhlIG5ldyBjbGljay0yLjIuZHRkIGhhcyBiZWVuIHB1Ymxpc2hlZCB0bw0KICAgICAgICAgIDxhIGhyZWY9Imh0dHA6Ly9jbGljay5hcGFjaGUub3JnL2R0ZHMvY2xpY2stMi4yLmR0ZCI+aHR0cDovL2NsaWNrLmFwYWNoZS5vcmcvZHRkcy9jbGljay0yLjIuZHRkPC9hPi4NCiAgICAgICAgICBJZiB5b3Ugd2FudCB5b3VyIGNvbmZpZ3VyYXRpb24gdG8gY29uZm9ybSB0byB0aGUgY2xpY2suZHRkLCBpbmNsdWRlDQogICAgICAgICAgdGhlIGZvbGxvd2luZyBkZWNsYXJhdGlvbiBpbiB5b3VyIGNsaWNrLnhtbDoNCiAgICAgICAgICA8cHJlIGNsYXNzPSJwcmV0dHlwcmludCI+Jmx0OyFET0NUWVBFIGNsaWNrLWFwcCBQVUJMSUMNCiAgICAgICAiLS8vQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24vL0RURCBDbGljayBDb25maWd1cmF0aW9uIDIuMi8vRU4iDQogICAgICAgImh0dHA6Ly9jbGljay5hcGFjaGUub3JnL2R0ZHMvY2xpY2stMi4yLmR0ZCImZ3Q7IDwvcHJlPg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBVcGRhdGVkIFZlbG9jaXR5IGxpYnJhcnkgdG8gdmVyc2lvbiAxLjYuNC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgVXBkYXRlZCBDYXllbm5lIGxpYnJhcnkgdG8gdmVyc2lvbiAzLjAuDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQoNCiAgPGR0PjxkaXYgY2xhc3M9InJlbGVhc2UtaGVhZGVyIj5BcmNoaXZlczwvZGl2PjwvZHQ+DQogIDxkdD48YSBuYW1lPSIyLjMuMC1NMSI+PC9hPlZlcnNpb24gMi4zLjAtTTEgLSAyOCBOb3ZlbWJlciAyMDEwPC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIFNlZSB0aGUgcmVsZWFzZSBub3RlcyBmb3IgPGEgaHJlZj0iIzIuMy4wIj4yLjMuMDwvYT4uDQogICAgPC9kaXY+DQogIDwvZGQ+DQoNCiAgPGR0PjxhIG5hbWU9IjIuMi4wLVJDMSI+PC9hPlZlcnNpb24gMi4yLjAtUkMxIC0gOCBNYXkgMjAxMDwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICBTZWUgdGhlIHJlbGVhc2Ugbm90ZXMgZm9yIDxhIGhyZWY9IiMyLjIuMCI+Mi4yLjA8L2E+Lg0KICAgIDwvZGl2Pg0KICA8L2RkPg0KDQogIDxkdD48YSBuYW1lPSIyLjEuMCI+PC9hPg0KICAgIDxkaXY+VmVyc2lvbiAyLjEuMCAtIDEwIEZlYnJ1YXJ5IDIwMTA8L2Rpdj4NCiAgPC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIj51cGdyYWRlIHBhdGg8L2E+DQogICAgICB3aGVuIHVwZ3JhZGluZyBmcm9tIHByZXZpb3VzIHJlbGVhc2VzLg0KICAgIDwvZGl2Pg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIDxiPlBsZWFzZSBOb3RlOjwvYj4NCiAgICAgIFRoaXMgcmVsZWFzZSByZXF1aXJlcyBKYXZhIDEuNSBvciBsYXRlci4NCiAgICA8L2Rpdj4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgPGI+TmV3IGV4YW1wbGVzOjwvYj4NCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtO21hcmdpbi1ib3R0b206IDJlbSI+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvZ2VuZXJhbC9wYWdlLWhlYWQtZGVtby5odG0iPg0KICAgICAgICBQYWdlIEhFQUQgZWxlbWVudHM8L2E+IGRlbW9uc3RyYXRlcyBob3cgdG8gYWRkDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvSnNJbXBvcnQuaHRtbCI+SnNJbXBvcnQ8L2E+LA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0pzU2NyaXB0Lmh0bWwiPkpzU2NyaXB0PC9hPiwNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Dc3NJbXBvcnQuaHRtbCI+Q3NzSW1wb3J0PC9hPg0KICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Dc3NTdHlsZS5odG1sIj5Dc3NTdHlsZTwvYT4NCiAgICAgICAgSEVBRCBlbGVtZW50cyB0byBhIFBhZ2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2dlbmVyYWwvY29udHJvbC1oZWFkLWRlbW8uaHRtIj4NCiAgICAgICAgQ29udHJvbCBIRUFEIGVsZW1lbnRzPC9hPiBkZW1vbnN0cmF0ZXMgaG93IHRvIGFkZA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0pzSW1wb3J0Lmh0bWwiPkpzSW1wb3J0PC9hPiBhbmQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Dc3NJbXBvcnQuaHRtbCI+Q3NzSW1wb3J0PC9hPg0KICAgICAgICBIRUFEIGVsZW1lbnRzIHRvIGEgY3VzdG9tIENvbnRyb2wuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2NvbnRyb2wvc3VibWl0LWxpbmstZGVtby5odG0iPg0KICAgICAgICAgIFN1Ym1pdExpbmsgRGVtbzwvYT4gc2hvd3MgaG93IHRvIHVzZSB0aGUgbmV3IDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9TdWJtaXRMaW5rLmh0bWwiPlN1Ym1pdExpbms8L2E+IGNvbnRyb2wuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL3RhYmxlL2xhcmdlLWRhdGFzZXQtZGVtby5odG0iPg0KICAgICAgICBMYXJnZSBEYXRhc2V0PC9hPiBpcyBhbiBleGFtcGxlIG9mIGEgVGFibGUgd2l0aCBhIGxhcmdlIG51bWJlciBvZiByb3dzDQogICAgICAgIGFuZCBob3cgdG8gbGF6aWx5IHBhZ2UgdGhyb3VnaCB0aGUgcm93cyB1c2luZyBhIGN1c3RvbSBkYXRhIHByb3ZpZGVyLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9wYW5lbC9yZXVzYWJsZS1wYW5lbC1kZW1vLmh0bSI+DQogICAgICAgICAgUmV1c2FibGUgUGFuZWw8L2E+IGlzIGFuIGV4YW1wbGUgb2YgYSByZXVzYWJsZSBQYW5lbA0KICAgICAgICAgIHdoaWNoIHByb3ZpZGVzIGEgRm9ybSBmb3IgY2FwdHVyaW5nIENsaWVudCBkZXRhaWxzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9xdWFydHovcXVhcnR6LWpvYi1zY2hlZHVsZXIuaHRtIj4NCiAgICAgICAgICBRdWFydHogSm9iIFNjaGVkdWxlcjwvYT4gaXMgYW4gZXhhbXBsZSBkZW1vbnN0cmF0aW5nIGhvdyB0byBpbnRlZ3JhdGUgdGhlIFF1YXJ0eiBKb2IgU2NoZWR1bGluZyBmcmFtZXdvcmsNCiAgICAgICAgICBpbnRvIGEgQ2xpY2sgYXBwbGljYXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2dlbmVyYWwvZXhjZWwtdGFibGUtZXhwb3J0Lmh0bSI+DQogICAgICAgICAgRXhjZWwgVGFibGUgRXhwb3J0ZXI8L2E+IGV4YW1wbGUgZGVtb25zdHJhdGVzIGhvdyB0byBleHBvcnQgYSBDbGljayBUYWJsZQ0KICAgICAgICAgIHRvIGFuIEV4Y2VsIHNwcmVhZHNoZWV0IHVzaW5nDQogICAgICAgICAgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3BvaS5hcGFjaGUub3JnLyI+QXBhY2hlIFBPSTwvYT4uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQoNCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgPGI+TmV3IGRvY3VtZW50YXRpb246PC9iPg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaT4NCiAgICAgICAgRG9jdW1lbnRhdGlvbiBoYXMgYmVlbiBjb252ZXJ0ZWQgdG8gRG9jYm9vayBhbmQgYXJlIG1hZGUgYXZhaWxhYmxlIGluDQogICAgICAgIHRocmVlIGRpZmZlcmVudCBmbGF2b3JzOiA8YSBocmVmPSJ1c2VyLWd1aWRlLmh0bWwiPlBERiwgSFRNTCAoc2luZ2xlIHBhZ2UpIGFuZCBIVE1MIChtdWx0aXBsZSBwYWdlcyk8L2E+Lg0KICAgICAgICBUaGFua3MgdG8gR2lsYmVydG8gQyBBbmRyYWRlIGZvciBkb2luZyB0aGUgY29udmVyc2lvbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ4MiI+NDgyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICBBZGRlZCBkb2N1bWVudGF0aW9uIGRlc2NyaWJpbmcgdGhlIG5ldyBIRUFEIGVsZW1lbnQgc3VwcG9ydC4NCiAgICAgICAgUGxlYXNlIHNlZSB0aGUgbmV3IHNlY3Rpb24gb24gUGFnZSBIRUFEIGVsZW1lbnRzDQogICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAyczEzLmh0bWwiPmhlcmU8L2E+IGFuZA0KICAgICAgICB0aGUgc2VjdGlvbiBvbiBDb250cm9sIEhFQUQgZWxlbWVudHMgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDNzMDUuaHRtbCI+aGVyZTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICBBZGRlZCBhIG5ldyBzZWN0aW9uLCA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMy5odG1sI2RlcGxveWluZy1yZXN0cmljdGVkLWVudiI+RGVwbG95aW5nIHJlc291cmNlcyBpbiBhIHJlc3RyaWN0ZWQgZW52aXJvbm1lbnQ8L2E+LA0KICAgICAgICBkZXNjcmliaW5nIGhvdyB0byBkZXBsb3kgc3RhdGljIHJlc291cmNlcyBpbiBlbnZpcm9ubWVudHMgd2hlcmUNCiAgICAgICAgV0FSL0VBUiBhcmUgbm90IHVucGFja2VkIG9yIHdoZXJlIGZpbGUgc3lzdGVtIHBlcm1pc3Npb25zIGFyZQ0KICAgICAgICByZXN0cmljdGVkLCBzdWNoIGFzDQogICAgICAgIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vYXBwZW5naW5lL2RvY3MvamF2YS9vdmVydmlldy5odG1sIj5Hb29nbGUgQXBwIEVuZ2luZTwvYT4uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQoNCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgPGI+RGVwcmVjYXRlZDo8L2I+DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIERlcHJlY2F0ZWQgbWV0aG9kczogPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI2dldEh0bWxJbXBvcnRzKCkiPkNvbnRyb2wuZ2V0SHRtbEltcG9ydHMoKTwvYT4gYW5kDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI2dldEh0bWxJbXBvcnRzKCkiPlBhZ2UuZ2V0SHRtbEltcG9ydHMoKTwvYT4uDQogICAgICAgICAgVGhlc2UgbWV0aG9kcyBoYXZlIGJlZW4gZGVwcmVjYXRlZCBpbiBmYXZvciBvZg0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNnZXRIZWFkRWxlbWVudHMoKSI+Q29udHJvbC5nZXRIZWFkRWxlbWVudHMoKTwvYT4NCiAgICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI2dldEhlYWRFbGVtZW50cygpIj5QYWdlLmdldEhlYWRFbGVtZW50cygpPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgRGVwcmVjYXRlZCBtZXRob2RzOiA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjZ2V0UGFnZUltcG9ydHMoKSI+UGFnZS5nZXRQYWdlSW1wb3J0cygpPC9hPg0KICAgICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0UGFnZUltcG9ydHMob3JnLmFwYWNoZS5jbGljay51dGlsLlBhZ2VJbXBvcnRzKSI+UGFnZS5zZXRQYWdlSW1wb3J0cygpPC9hPi4NCiAgICAgICAgICBUaGVzZSBtZXRob2RzIGhhdmUgYmVlbiBkZXByZWNhdGVkIGluIGZhdm9yIG9mDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI2dldEhlYWRFbGVtZW50cygpIj5QYWdlLmdldEhlYWRFbGVtZW50cygpPC9hPi4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0OiAtMmVtOyBtYXJnaW4tdG9wOiAxLjVlbTsgbWFyZ2luLWJvdHRvbTogMWVtOyI+DQogICAgICA8Yj5OZXcgZmVhdHVyZXMgYW5kIGlzc3VlcyByZXNvbHZlZDo8L2I+DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vYXBwZW5naW5lL2RvY3MvamF2YS9vdmVydmlldy5odG1sIj5Hb29nbGUgQXBwIEVuZ2luZTwvYT4sDQogICAgICAgICAgYSBmcmVlIEphdmEgaG9zdGluZyBlbnZpcm9ubWVudCBmcm9tIEdvb2dsZS4gVGhpcyBwcm92aWRlcyBhbiBpZGVhbA0KICAgICAgICAgIGVudmlyb25tZW50IGZvciBzdHVkZW50cyBhbmQgc3RhcnR1cHMgdG8gZWFzaWx5IGhvc3QgdGhlaXIgQ2xpY2sNCiAgICAgICAgICBhcHBsaWNhdGlvbnMgb25saW5lLiBTZWUgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9nYWUvR29vZ2xlQXBwRW5naW5lTGlzdGVuZXIuaHRtbCI+R29vZ2xlQXBwRW5naW5lTGlzdGVuZXI8L2E+DQogICAgICAgICAgZm9yIGRldGFpbHMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU2MCI+NTYwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIGFuIGluLW1lbW9yeSA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2dhZS9NZW1vcnlGaWxlVXBsb2FkU2VydmljZS5odG1sIj5GaWxlIFVwbG9hZCBTZXJ2aWNlPC9hPg0KICAgICAgICAgIHRoYXQgY2FuIGJlIHVzZWQgZm9yIHVwbG9hZGluZyBmaWxlcyBpbiBhIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vYXBwZW5naW5lL2RvY3MvamF2YS9vdmVydmlldy5odG1sIj5Hb29nbGUgQXBwIEVuZ2luZTwvYT4NCiAgICAgICAgICBlbnZpcm9ubWVudC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgdGVtcGxhdGVzIHdpdGggY3VzdG9tIGV4dGVuc2lvbnMgdGhyb3VnaCB0aGUgbmV3DQogICAgICAgICAgQ29uZmlnU2VydmljZS48YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9zZXJ2aWNlL0NvbmZpZ1NlcnZpY2UuaHRtbCNpc1RlbXBsYXRlKGphdmEubGFuZy5TdHJpbmcpIj5pc1RlbXBsYXRlPC9hPg0KICAgICAgICAgIG1ldGhvZC4gVGhlIGRlZmF1bHQgQ29uZmlnU2VydmljZSBpbXBsZW1lbnRhdGlvbiwgWG1sQ29uZmlnU2VydmljZSwgcHJvdmlkZXMNCiAgICAgICAgICBzdXBwb3J0IGZvciB0aGUgZXh0ZW5zaW9ucyA8dHQ+Lmh0bTwvdHQ+IGFuZCA8dHQ+LmpzcDwvdHQ+LCBidXQgbmV3IGV4dGVuc2lvbnMNCiAgICAgICAgICBjYW4gYmUgcHJvdmlkZWQgaW4gYSBzdWJjbGFzcy4gU2VlIHRoZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9zZXJ2aWNlL1htbENvbmZpZ1NlcnZpY2UuaHRtbCNpc1RlbXBsYXRlKGphdmEubGFuZy5TdHJpbmcpIj5KYXZhRG9jPC9hPg0KICAgICAgICAgIGZvciBkZXRhaWxzDQogICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NjgiPjU2ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBzdXBwb3J0IHRvIHRoZSBQYWdlIGNsYXNzIGZvciBjb25kaXRpb25hbGx5IGluY2x1ZGluZyBDb250cm9sDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI2dldEhlYWRFbGVtZW50cygpIj5oZWFkIGVsZW1lbnRzPC9hPg0KICAgICAgICAgIHRocm91Z2ggdGhlIG5ldyBtZXRob2QgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3NldEluY2x1ZGVDb250cm9sSGVhZEVsZW1lbnRzKGJvb2xlYW4pIj5pbmNsdWRlQ29udHJvbEhlYWRFbGVtZW50czwvYT4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU3MSI+NTcxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIHN1cHBvcnQgdG8gZGVwbG95IHJlc291cmNlcyBpbnNpZGUgSkFScyBmcm9tIHRoZSBTZXJ2bGV0IDMuMCBjb21wbGlhbnQNCiAgICAgICAgICBsb2NhdGlvbiwgPHR0Pk1FVEEtSU5GL3Jlc291cmNlczwvdHQ+LiBDbGljaydzIG93biBwcmUtcGFja2FnZWQgcmVzb3VyY2VzDQogICAgICAgICAgYXJlIG5vdyBhbHNvIGxvY2F0ZWQgaW4gdGhlIEpBUiB1bmRlciA8dHQ+TUVUQS1JTkYvcmVzb3VyY2VzPC90dD4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU3MCI+NTcwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIG5ldyBDYWxlbmRhciBwb3B1cCB0byBEYXRlRmllbGQuIFRoaXMgQ2FsZW5kYXIgcG9wdXAgdXNlcw0KICAgICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vcC9jYWxlbmRhcmRhdGVzZWxlY3QvIj5DYWxlbmRhciBEYXRlIFNlbGVjdDwvYT4NCiAgICAgICAgICB3aGljaCBpcyBiYXNlZCBvbiB0aGUgUHJvdG90eXBlIEphdmFTY3JpcHQgbGlicmFyeS4NCiAgICAgICAgICA8cC8+DQogICAgICAgICAgUGxlYXNlIG5vdGUgaWYgeW91IGRvbid0IHdhbnQgYSBkZXBlbmRlbmN5IG9uIHRoZSBQcm90b3R5cGUgbGlicmFyeQ0KICAgICAgICAgIHlvdSBjYW4gdXNlIHRoZSB0aGlyZC1wYXJ0eQ0KICAgICAgICAgIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vcC9jbGljay1jYWxlbmRhci8iPkNsaWNrIENhbGVuZGFyPC9hPg0KICAgICAgICAgIGluc3RlYWQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIGZpcnN0IGNsYXNzIHN1cHBvcnQgZm9yIEhFQUQgZWxlbWVudHMgc3VjaCBhcyBKYXZhU2NyaXB0IGFuZCBDc3MuDQogICAgICAgICAgVGhlIGZvbGxvd2luZyBjbGFzc2VzIHdlcmUgYWRkZWQ6DQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9FbGVtZW50Lmh0bWwiPkVsZW1lbnQ8L2E+LA0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvUmVzb3VyY2VFbGVtZW50Lmh0bWwiPlJlc291cmNlRWxlbWVudDwvYT4sDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Kc0ltcG9ydC5odG1sIj5Kc0ltcG9ydDwvYT4sDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Kc1NjcmlwdC5odG1sIj5Kc1NjcmlwdDwvYT4sDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Dc3NJbXBvcnQuaHRtbCI+Q3NzSW1wb3J0PC9hPg0KICAgICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0Nzc1N0eWxlLmh0bWwiPkNzc1N0eWxlPC9hPi4NCiAgICAgICAgICBBIG5ldyBtZXRob2Qgd2FzIGFkZGVkIHRvIFBhZ2UgYW5kIENvbnRyb2w6IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNnZXRIZWFkRWxlbWVudHMoKSI+Q29udHJvbC5nZXRIZWFkRWxlbWVudHMoKTwvYT4NCiAgICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI2dldEhlYWRFbGVtZW50cygpIj5QYWdlLmdldEhlYWRFbGVtZW50cygpPC9hPg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTAxIj41MDE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL1N1Ym1pdExpbmsuaHRtbCI+U3VibWl0TGluazwvYT4gY29udHJvbA0KICAgICAgICAgIHRoYXQgY2FuIHN1Ym1pdCBhIEZvcm0gWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01MTkiPjUxOTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgICBBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvSGlkZGVuTGlzdC5odG1sIj5IaWRkZW5MaXN0PC9hPiBjb250cm9sDQogICAgICAgICAgZm9yIHJlbmRlcmluZyBhbmQgc3VibWl0dGluZyBhIGxpc3Qgb2YgaGlkZGVuIGZpZWxkcyBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ5MSI+NDkxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIHBsdWdnYWJsZSBzZWN1cml0eSBhY2Nlc3MgY29udHJvbGxlciAoPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9zZWN1cml0eS9BY2Nlc3NDb250cm9sbGVyLmh0bWwiPkFjY2Vzc0NvbnRyb2xsZXI8L2E+KSB0byBNZW51IGNsYXNzLg0KICAgICAgICAgIFRoaXMgcGx1Z2dhYmxlIGludGVyZmFjZSBlbmFibGUgdXNlIG9mIHNlY3VyaXR5IGZyYW1ld29ya3Mgc3VjaCBhcyBTcHJpbmcgU2VjdXJpdHkgKEFjZWdpKSBvciBKU2VjdXJpdHkgdG8gY29udHJvbCB1c2VyIGFjY2VzcyB0byBNZW51IGl0ZW1zLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEZW1ldHJpb3MgS3lyaWFraXMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvY2xpY2svYnJvd3NlL0NMSy00MDYiPjQwNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBhbiBBbnQgdGFzaywgY2FsbGVkIERlcGxveVRhc2ssIGZvciBkZXBsb3lpbmcgc3RhdGljIHJlc291cmNlcw0KICAgICAgICAgIGF0IGJ1aWxkIHRpbWUuIFRoaXMgdGFzayBpcyB1c2VmdWwgd2hlbiBkZXBsb3lpbmcgQ2xpY2sgYXBwbGljYXRpb25zDQogICAgICAgICAgaW4gcmVzdHJpY3RlZCBlbnZpcm9ubWVudHMuIEZvciBtb3JlIGRldGFpbHMgc2VlIHRoZSBzZWN0aW9uOg0KICAgICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAzLmh0bWwjZGVwbG95aW5nLXJlc3RyaWN0ZWQtZW52Ij5kZXBsb3lpbmcgcmVzb3VyY2VzIGluIGEgcmVzdHJpY3RlZCBlbnZpcm9ubWVudDwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIGEgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svc2VydmljZS9SZXNvdXJjZVNlcnZpY2UuaHRtbCI+UmVzb3VyY2VTZXJ2aWNlPC9hPiwNCiAgICAgICAgICBmb3Igc2VydmluZyBzdGF0aWMgcmVzb3VyY2VzIGF0IHJ1bnRpbWUuIFRoaXMgc2VydmljZSBpcyB1c2VmdWwgd2hlbg0KICAgICAgICAgIGRlcGxveWluZyBDbGljayBhcHBsaWNhdGlvbnMgaW4gcmVzdHJpY3RlZCBlbnZpcm9ubWVudHMuIEZvciBtb3JlIGRldGFpbHMNCiAgICAgICAgICBzZWUgdGhlIHNlY3Rpb246DQogICAgICAgICAgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDRzMDMuaHRtbCNkZXBsb3lpbmctcmVzdHJpY3RlZC1lbnYiPmRlcGxveWluZyByZXNvdXJjZXMgaW4gYSByZXN0cmljdGVkIGVudmlyb25tZW50PC9hPg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9jbGljay9icm93c2UvQ0xLLTU2NCI+NTY0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIG1ldGhvZCwNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCNjcmVhdGVUZW1wbGF0ZU1vZGVsKG9yZy5hcGFjaGUuY2xpY2suUGFnZSwgb3JnLmFwYWNoZS5jbGljay5Db250ZXh0KSI+Q2xpY2tVdGlscy5jcmVhdGVUZW1wbGF0ZU1vZGVsPC9hPiwNCiAgICAgICAgICB3aGljaCByZXR1cm5zIGEgdGVtcGxhdGUgbW9kZWwgY29udGFpbmluZyBvYmplY3RzIHN1Y2ggYXMgdGhlIENvbnRleHQNCiAgICAgICAgICBwYXRoLCBQYWdlIHBhdGgsIEhUVFAgcmVxdWVzdCwgSFRUUCByZXNwb25zZSwgSFRUUCBzZXNzaW9uIGV0Yy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgYWJpbGl0eSB0byBzcGVjaWZ5IGEgY3VzdG9tIFRyZWVOb2RlIGljb24gdGhyb3VnaCB0aGUgbmV3IG1ldGhvZA0KICAgICAgICAgIFRyZWVOb2RlLjxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9UcmVlTm9kZS5odG1sI3NldEljb24oamF2YS5sYW5nLlN0cmluZykiPnNldEljb24oU3RyaW5nKTwvYT4uDQogICAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBUaW0gSG9vcGVyDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00OTQiPjQ5NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBtZXRob2QgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Gb3JtYXQuaHRtbCN1cmwoamF2YS5sYW5nLk9iamVjdCkiPkZvcm1hdC51cmw8L2E+DQogICAgICAgICAgZm9yIGVuY29kaW5nIFVSTCdzIGluIHRlbXBsYXRlcw0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzk5Ij4zOTk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgbWV0aG9kDQogICAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0ZpZWxkQ29sdW1uLmh0bWwjc2V0UHJvcGVydHkoamF2YS5sYW5nLk9iamVjdCwgamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLk9iamVjdCkiPkZpZWxkQ29sdW1uLnNldFByb3BlcnR5PC9hPg0KICAgICAgICAgIHRoYXQgY2FuIGJlIG92ZXJyaWRlbiB0byBwcm92aWRlIGN1c3RvbSBiaW5kaW5nIGZvciBjb21wbGV4DQogICAgICAgICAgZG9tYWluIG9iamVjdHMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgV2FybmVySmFuIFZlbGRodWlzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01MjgiPjUyODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBUeXBlQ29udmVydGVyIGNvbmZpZ3VyYXRpb24gb3B0aW9uIHRvIENsaWNrU2VydmxldC4gDQogICAgICAgICAgU2VlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NsaWNrU2VydmxldC5odG1sI2dldFR5cGVDb252ZXJ0ZXIoKSI+Z2V0VHlwZUNvbnZlcnRlcigpPC9hPg0KICAgICAgICAgIG1ldGhvZCBmb3IgZGV0YWlscy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIEpvc2VwaCBTY2htaWR0IGFuZCBmaXhlZCBieSBBZHJpYW4gQS4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUzOSI+NTM5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvc2VydmljZS9TbGY0akxvZ1NlcnZpY2UuaHRtbCI+U2xmNGpMb2dTZXJ2aWNlPC9hPg0KICAgICAgICAgIGZvciBzdXBwb3J0aW5nIG11bHRpcGxlIGFwcGxpY2F0aW9uIHNlcnZlcnMuIA0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBPbGl2ZXIgQnVybg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTU1Ij41NTU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9CaW5kYWJsZS5odG1sIj5AQmluZGFibGU8L2E+IA0KICAgICAgICAgIGFubm90YXRpb24gc3VwcG9ydCBmb3IgcGFnZSBmaWVsZCBhdXRvYmluZGluZy4gQEJpbmRhYmxlIHN1cHBvcnRzIHB1YmxpYywNCiAgICAgICAgICBwcm90ZWN0ZWQgYW5kIHByaXZhdGUgUGFnZSB2YXJpYWJsZXMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU1NiI+NTU2PC9hPiwgDQogICAgICAgICAgIDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01OTkiPjU5OTwvYT4gDQogICAgICAgICAgXS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHByb3BlcnR5IGZpbGVzIHdpdGggdHJhbnNsYXRpb24gZm9yIHRoZSBSdXNzaWFuIGxhbmd1YWdlLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEFuZHJleSBSeWJpbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYwNyI+NjA3PC9hPl0sDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjExIj42MTE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBuZXcgVHJlZSBtZXRob2RzDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9UcmVlLmh0bWwjc2V0V2lkdGgoamF2YS5sYW5nLlN0cmluZykiPnNldFdpZHRoPC9hPiAvDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9UcmVlLmh0bWwjZ2V0V2lkdGgoKSI+Z2V0V2lkdGg8L2E+DQogICAgICAgIGFuZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZS5odG1sI3NldEhlaWdodChqYXZhLmxhbmcuU3RyaW5nKSI+c2V0SGVpZ2h0PC9hPiAvDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9UcmVlLmh0bWwjZ2V0SGVpZ2h0KCkiPmdldEhlaWdodDwvYT4uDQogICAgICAgIEFsc28gZml4ZWQgcmVuZGVyaW5nIGlzc3VlcyBpbiBJRTYvNyBmb3IgbG9uZyBub2RlIGxhYmVscyB0aGF0IG92ZXJmbG93DQogICAgICAgIHRoZSB0cmVlIHdpZHRoIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjE2Ij42MTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgVGhlIGNsaWNrLmR0ZCBoYXMgYmVlbiBwdWJsaXNoZWQgdG8NCiAgICAgICAgICA8YSBocmVmPSJodHRwOi8vY2xpY2suYXBhY2hlLm9yZy9kdGRzL2NsaWNrLTIuMS5kdGQiPmh0dHA6Ly9jbGljay5hcGFjaGUub3JnL2R0ZHMvY2xpY2stMi4xLmR0ZDwvYT4uDQogICAgICAgICAgSWYgeW91IHdhbnQgeW91ciBjb25maWd1cmF0aW9uIHRvIGNvbmZvcm0gdG8gdGhlIGNsaWNrLmR0ZCwgaW5jbHVkZQ0KICAgICAgICAgIHRoZSBmb2xsb3dpbmcgZGVjbGFyYXRpb24gaW4geW91ciBjbGljay54bWw6DQogICAgICAgICAgPHByZSBjbGFzcz0icHJldHR5cHJpbnQiPiZsdDshRE9DVFlQRSBjbGljay1hcHAgUFVCTElDDQogICAgICAgIi0vL0FwYWNoZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLy9EVEQgQ2xpY2sgQ29uZmlndXJhdGlvbiAyLjEvL0VOIg0KICAgICAgICJodHRwOi8vY2xpY2suYXBhY2hlLm9yZy9kdGRzL2NsaWNrLTIuMS5kdGQiJmd0OyA8L3ByZT4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgRm9ybSB2YWxpZGF0aW9uIHRvIGFsbG93IEZvcm0gc3ViY2xhc3NlcyB0byBvdmVycmlkZSB0aGUNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCN2YWxpZGF0ZSgpIj52YWxpZGF0ZTwvYT4NCiAgICAgICAgICBtZXRob2QgYW5kIGltcGxlbWVudCBjcm9zcy1maWVsZCB2YWxpZGF0aW9uLiBUaGUgZm9sbG93aW5nDQogICAgICAgICAgY2hhbmdlcyB3ZXJlIG1hZGU6IHRoZSBwcmV2aW91cyA8dHQ+dmFsaWRhdGU8L3R0PiBtZXRob2Qgd2FzIHJlbmFtZWQNCiAgICAgICAgICB0byA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCN2YWxpZGF0ZUZpbGVVcGxvYWQoKSI+dmFsaWRhdGVGaWxlVXBsb2FkPC9hPg0KICAgICAgICAgIGFuZCBhIG5ldyBlbXB0eSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCN2YWxpZGF0ZSgpIj52YWxpZGF0ZTwvYT4NCiAgICAgICAgICBtZXRob2Qgd2FzIGludHJvZHVjZWQsIHRoYXQgY2FuIHNhZmVseSBiZSBvdmVycmlkZGVuIGluIHN1YmNsYXNzZXMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU3MiI+NTcyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIFBhZ2UgcmVkaXJlY3QgdG8gc3VwcG9ydCBwYXJhbWV0ZXJzLiBTZWUgdGhlIG5ldyBQYWdlIG1ldGhvZHMNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0UmVkaXJlY3QoamF2YS5sYW5nLlN0cmluZywgamF2YS51dGlsLk1hcCkiPnNldFJlZGlyZWN0KFN0cmluZywgTWFwKTwvYT4NCiAgICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3NldFJlZGlyZWN0KGphdmEubGFuZy5DbGFzcywgamF2YS51dGlsLk1hcCkiPnNldFJlZGlyZWN0KENsYXNzLCBNYXApPC9hPg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQWRyaWFuDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01MzYiPjUzNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBMaW5rIENvbnRyb2xzIHRvIHN1cHBvcnQgbXVsdGl2YWx1ZWQgcGFyYW1ldGVycyB0aHJvdWdoIHRoZQ0KICAgICAgICAgIG5ldyBBYnN0cmFjdExpbmsgbWV0aG9kcyA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0TGluay5odG1sI2dldFBhcmFtZXRlclZhbHVlcyhqYXZhLmxhbmcuU3RyaW5nKSI+Z2V0UGFyYW1ldGVyVmFsdWVzKCk8L2E+DQogICAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWJzdHJhY3RMaW5rLmh0bWwjc2V0UGFyYW1ldGVyVmFsdWVzKGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5TdHJpbmdbXSkiPnNldFBhcmFtZXRlclZhbHVlcygpPC9hPg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTU0Ij41NTQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgVGFibGUgdG8gc3VwcG9ydCB2ZXJ5IGxhcmdlIGRhdGFzZXRzIGJ5IHByb21vdGluZyB0aGUgbWV0aG9kcw0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCNnZXRGaXJzdFJvdygpIj5nZXRGaXJzdFJvdygpPC9hPg0KICAgICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1RhYmxlLmh0bWwjZ2V0TGFzdFJvdygpIj5nZXRMYXN0Um93KCk8L2E+DQogICAgICAgICAgYXMgcHVibGljLiBUaGVzZSBtZXRob2RzIHByb3ZpZGUgdGhlIG5lY2Vzc2FyeSBpbmZvcm1hdGlvbiB0byBvbmx5DQogICAgICAgICAgcmV0cmlldmUgdGhlIGRpc3BsYXllZCByb3dzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01MDQiPjUwNDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBMaW5rRGVjb3JhdG9yIHRvIHN1cHBvcnQgdGFyZ2V0IGlkZW50aWZpZXIgcHJvcGVydHkgcGFyYW1ldGVyIG5hbWVzLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEZW1ldHJpb3MgS3lyaWFraXMgYW5kIGZpeGVkIGJ5IGZpeGVkIGJ5IEFkcmlhbiBBLg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDAwIj40MDA8L2E+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+DQogICAgICAgICAgVXBkYXRlZCBQcm90b3R5cGUuanMgbGlicmFyeSB0byB2ZXJzaW9uIDEuNi4xLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KDQogIDxkdD48YSBuYW1lPSIyLjEuMC1SQzEiPjwvYT5WZXJzaW9uIDIuMS4wLVJDMSAoQXBhY2hlIGluY3ViYXRvcikgLSAyOCBKdW5lIDIwMDk8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgU2VlIHRoZSByZWxlYXNlIG5vdGVzIGZvciA8YSBocmVmPSIjMi4xLjAiPjIuMS4wPC9hPi4NCiAgICA8L2Rpdj4NCiAgPC9kZD4NCg0KICA8ZHQ+PGEgbmFtZT0iMi4wLjEiPjwvYT5WZXJzaW9uIDIuMC4xIChBcGFjaGUgaW5jdWJhdG9yKSAtIDE1IEZlYnJ1YXJ5IDIwMDk8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgSU1QT1JUQU5UIGJlIHN1cmUgdG8gcmVhZCB0aGUgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjMS41Ij51cGdyYWRlIHBhdGg8L2E+IHdoZW4gdXBncmFkaW5nIGZyb20gQ2xpY2sgMS40IG9yIGVhcmxpZXIuDQogICAgPC9kaXY+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDogMTVweDsgbWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgVGhpcyBpcyBvdXIgZmlyc3QgQXBhY2hlIEluY3ViYXRvciByZWxlYXNlIGFuZCBpcyBiYXNlZCBvbiA8YSBocmVmPSIjMS41LjEiPkNsaWNrIDEuNS4xPC9hPi4NCiAgICAgIDxwLz4NCiAgICAgIFBsZWFzZSBub3RlIHRoYXQgYmVjYXVzZSBvZiBsaWNlbnNpbmcgaXNzdWVzLCBjZXJ0YWluIHRoaXJkLXBhcnR5DQogICAgICBsaWJyYXJpZXMgd2VyZSByZW1vdmVkIGFuZCBhcmUgaG9zdGVkIGV4dGVybmFsbHkuDQogICAgPC9kaXY+DQogIDwvZGQ+DQoNCiAgPGR0PjxhIG5hbWU9IjEuNS4xIj48L2E+VmVyc2lvbiAxLjUuMSAocHJlLUFwYWNoZSkgLSAyMyBKYW51YXJ5IDIwMDk8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgSU1QT1JUQU5UIGJlIHN1cmUgdG8gcmVhZCB0aGUgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjMS41Ij51cGdyYWRlIHBhdGg8L2E+IHdoZW4gdXBncmFkaW5nIGZyb20gQ2xpY2sgMS40IG9yIGVhcmxpZXIuDQogICAgPC9kaXY+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgUGxlYXNlIG5vdGUgdGhhdCB0aGlzIHJlbGVhc2UgaXMgcHJvdmlkZWQgb3V0c2lkZSBvZiB0aGUgQVNGIGFuZCBpcyBub3QNCiAgICAgIGVuZG9yc2VkIG9yIGFwcHJvdmVkIGJ5IHRoZSBBcGFjaGUgU29mdHdhcmUgRm91bmRhdGlvbi4NCiAgICA8L2Rpdj4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOiAxNXB4OyBtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+IA0KICAgICAgVGhlIGZvbGxvd2luZyBpc3N1ZXMgd2VyZSByZXNvbHZlZCBzaW5jZSAxLjU6DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBUdXJraXNoIGxhbmd1YWdlIHN1cHBvcnQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQWxpIE9rLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ3NiI+NDc2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBleGNlcHRpb24gaGFuZGxpbmcgd2hlbiBhIENvbnRyb2wgbmFtZSBpcyBub3QgZGVmaW5lZA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ3MyI+NDczPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBuZXcgY29uc3RydWN0b3JzIHRvIGV4dHJhIGNvbnRyb2xzIHdoaWNoIGFjY2VwdHMgdGhlIDx0dD5zaXplPC90dD4NCiAgICAgICAgYXR0cmlidXRlLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQ2hyaXN0b3BoZSBGb2lyZXQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NzUiPjQ3NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgTWVzc2FnZUZvcm1hdCBzdXBwb3J0IHRvIEZvcm1hdC4gTmV3IG1ldGhvZHMgaW5jbHVkZQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0Zvcm1hdC5odG1sI21lc3NhZ2UoamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLk9iamVjdCkiPm1lc3NhZ2UoU3RyaW5nLCBPYmplY3QpPC9hPg0KICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Gb3JtYXQuaHRtbCNtZXNzYWdlKGphdmEubGFuZy5TdHJpbmcsIGphdmEudXRpbC5MaXN0KSI+bWVzc2FnZShTdHJpbmcsIExpc3QpPC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFl1IEtvYmF5YXNoaQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ3NCI+NDc0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyB0byBDaGVja2JveFRyZWUgdG8gaW1wcm92ZSBjdXN0b21pemF0aW9uLiBUaGUgbmV3IG1ldGhvZHMNCiAgICAgICAgaW5jbHVkZSA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvQ2hlY2tib3hUcmVlLmh0bWwjcmVuZGVyQ2hlY2tib3gob3JnLmFwYWNoZS5jbGljay51dGlsLkh0bWxTdHJpbmdCdWZmZXIsIG9yZy5hcGFjaGUuY2xpY2suZXh0cmFzLnRyZWUuVHJlZU5vZGUpIj5yZW5kZXJDaGVja2JveDwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9DaGVja2JveFRyZWUuaHRtbCNnZXRJbnB1dFR5cGUoKSI+Z2V0SW5wdXRUeXBlPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGNzdiBtaW1lIHR5cGUuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBbHZpbiBUb3duc2VuZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFVSTCByZW5kZXJpbmcgdG8gZW5jb2RlIGFtcGVyc2FuZCBjaGFyYWN0ZXJzLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ4MyI+NDgzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBIaWRkZW5GaWVsZCB0byB3b3JrIHdpdGggamF2YS5zcWwuVGltZXN0YW1wLCBqYXZhLnNxbC5UaW1lIGFuZCBqYXZhLnNxbC5EYXRlLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ4NCI+NDg0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBXZWJhcHBMb2FkZXIgdG8gcmVsb2FkIFZlbG9jaXR5IGdsb2JhbCBtYWNybydzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDY3Ij40Njc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFBhZ2Uuc2V0UmVkaXJlY3QgdG8gY2hlY2sgaWYgcmVkaXJlY3QgcGF0aCBzdGFydHMgd2l0aCBjb250ZXh0IHBhdGguDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBDaHJpc3RvcGhlIEZvaXJldA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2OCI+NDY4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBhIHJlZ3Jlc3Npb24gd2hlbiBtYW51YWxseSBzZXR0aW5nIHRoZSBQYWdlIHBhdGggdG8gYSBKU1AuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTQxIj4xNDE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIERhdGVGaWVsZCdzIEZyZW5jaCB0cmFuc2xhdGlvbi4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFsdmluIFRvd25zZW5kLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KDQogIDxkdD48YSBuYW1lPSIxLjUiPjwvYT5WZXJzaW9uIDEuNSAtIDIgTm92ZW1iZXIgMjAwODwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICBJTVBPUlRBTlQgYmUgc3VyZSB0byByZWFkIHRoZSA8YSBocmVmPSJ1cGdyYWRlLXBhdGguaHRtbCMxLjUiPnVwZ3JhZGUgcGF0aDwvYT4gd2hlbiB1cGdyYWRpbmcgZnJvbSBDbGljayAxLjQgb3IgZWFybGllci4NCiAgICA8L2Rpdj4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOiAxNXB4OyBtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+IA0KICAgICAgVGhlIGZvbGxvd2luZyBpc3N1ZXMgd2VyZSByZXNvbHZlZCBzaW5jZSAxLjUgUkMzOg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgRHV0Y2ggbGFuZ3VhZ2Ugc3VwcG9ydCwgY29udHJpYnV0ZWQgYnkgQ2hyaXN0b3BoZXIgSGlnaHdheS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIEZvcm0gdG8gcHJvY2VzcyBjb250cm9scyBldmVuIGlmIHRoZWlyIG5hbWVzIGlzIG5vdCBkZWZpbmVkLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2MyI+NDYzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDb250YWluZXJVdGlscy5jb3B5VG8gd2hlcmUgdGhlIHdyb25nIGdldHRlciBtZXRob2QgY291bGQgYmUgdXNlZA0KICAgICAgICB3aGVuIGEgZG9tYWluIG9iamVjdCBjb250YWlucyBtdWx0aXBsZSBvdmVybG9hZGVkIGdldHRlciBtZXRob2RzLiBUaGlzDQogICAgICAgIGlzc3VlIHdhcyByYWlzZWQgYnkgQWx2aW4gVG93bnNlbmQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NjEiPjQ2MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgQ29sdW1uIGludGVybmFsIENvbXBhcmF0b3Igd2hpY2ggZG9lcyBub3QgdGFrZSBzb3J0IG9yZGVyIGludG8NCiAgICAgICAgY29uc2lkZXJhdGlvbiBmb3Igbm9uIENvbXBhcmFibGUgaW5zdGFuY2VzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDYyIj40NjI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFBhbmVsLmdldElkKCkgdG8gcmV0dXJuIG51bGwgaWYgbmFtZSBpcyBub3QgZGVmaW5lZA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2NCI+NDY0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBWZWxvY2l0eVRlbXBsYXRlU2VydmljZSB0byBjYXRlciBmb3IgY3VzdG9tIGRlZmluZWQgVmVsb2NpdHkgbG9nZ2Vycy4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFZpa3JhbSBOYXRhcmFqYW4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NjUiPjQ2NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KDQogIDxkdD48YSBuYW1lPSIxLjUtUkMzIj48L2E+VmVyc2lvbiAxLjUgUkMzIC0gMTkgT2N0b2JlciAyMDA4PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0OiAtMmVtOyBtYXJnaW4tdG9wOiAxLjVlbTsgbWFyZ2luLWJvdHRvbTogMWVtOyI+DQogICAgICBOZXcgZXhhbXBsZXM6DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL3dpemFyZC93aXphcmQuaHRtIj4NCiAgICAgICAgICBXaXphcmQgZGVtbzwvYT4gc2hvd3MgaG93IHRvIGxldmVyYWdlIGEgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDJzMDkuaHRtbCI+c3RhdGVmdWw8L2E+DQogICAgICAgICAgcGFnZSBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9QYW5lbC5odG1sIj5QYW5lbHM8L2E+DQogICAgICAgICAgdG8gY3JlYXRlIGEgcHJvY2VzcyBmbG93LiBFYWNoIFN0ZXAgaW4gdGhlIHByb2Nlc3MgaXMgcmVwcmVzZW50ZWQgYnkgYQ0KICAgICAgICAgIFBhbmVsIHdoaWNoIGlzIG1hbmFnZWQgYnkgdGhlIHN0YXRlZnVsIFBhZ2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2NvbnRyb2wvcG9wdWxhdGUtb24tc2VsZWN0Lmh0bSI+DQogICAgICAgICAgUG9wdWxhdGUgb24gc2VsZWN0PC9hPiBzaG93cyBob3cgaXRlbXMgaW4gb25lIGNvbWJvIGJveCBpcyBwb3B1bGF0ZWQNCiAgICAgICAgICBiYXNlZCBvbiB0aGUgc2VsZWN0ZWQgaXRlbSBpbiBhbm90aGVyIHVzaW5nIEphdmFTY3JpcHQuDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL3RhYmxlL2VkaXQtZm9ybS10YWJsZS5odG0iPg0KICAgICAgICAgIEZvcm1UYWJsZSBkZW1vPC9hPiBzaG93cyBob3cgYSBGb3JtVGFibGUgY2FuIGJlIHVzZWQgdG9nZXRoZXIgd2l0aCBhbg0KICAgICAgICAgIGV4aXN0aW5nIEZvcm0uDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL3RyZWUvcGFnZS1saW5rLXRyZWUtcGFnZS5odG0iPg0KICAgICAgICAgIFBhZ2UgbGluayB0cmVlPC9hPiBwcm92aWRlcyBhIGRlbW9uc3RyYXRpb24gb2YgdXNpbmcgdGhlIFRyZWUgY29tcG9uZW50DQogICAgICAgICAgdG8gbGluayB0byBkaWZmZXJlbnQgcGFnZXMuDQogICAgICA8L2xpPg0KICAgIDwvdWw+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+Lg0KICAgICAgICBZb3UgY2FuIGZpbmQgYW4gZXhhbXBsZSBvZiBIdG1sRm9ybSBpbiBhY3Rpb24gPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvZm9ybS9jb250YWN0LWRldGFpbHMuaHRtIj5oZXJlPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG11bHRpcGxlIHBhZ2UgcGFja2FnZSBkZWZpbml0aW9ucyBpbiBjbGljay54bWwgY29uZmlndXJhdGlvbi4NCiAgICAgICAgU2VlIHRoZSBjb25maWd1cmF0aW9uIHRvcGljIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAyLmh0bWwjYXBwbGljYXRpb24tbXVsdGlwbGUtcGFja2FnZXMiPk11bHRpcGxlIFBhZ2VzIFBhY2thZ2VzPC9hPg0KICAgICAgICBmb3IgbW9yZSBkZXRhaWxzLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUmljYXJkbyBSLiBMZWNoZXRhDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzI4Ij4zMjg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGNvbmZpZ3VyYWJsZSB0YWJsZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1RhYmxlUGFnaW5hdG9yLmh0bWwiPlBhZ2luYXRvcjwvYT4gc3VwcG9ydA0KICAgICAgICBhbmQgYW4gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL1RhYmxlSW5saW5lUGFnaW5hdG9yLmh0bWwiPklubGluZVBhZ2luYXRvcjwvYT4uDQogICAgICAgIEEgbmV3IDxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL3RhYmxlL3RhYmxlLXBhZ2luYXRvci5odG0iPmV4YW1wbGU8L2E+DQogICAgICAgIHNob3dzIHRoZSBkaWZmZXJlbnQgUGFnaW5hdG9yIG9wdGlvbnMgYXZhaWxhYmxlLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgR3VzdGF2IFdlYmVyDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzkwIj4zOTA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHJlYWRvbmx5IGFuZCBkaXNhYmxlZCBzdXBwb3J0IHRvIEZpZWxkU2V0LiBJZiBlbmFibGVkIEZpZWxkcyBjb250YWluZWQNCiAgICAgICAgaW4gRmllbGRTZXQgd2lsbCBiZSBkaXNhYmxlZCBvciBtYWRlIHJlYWRvbmx5Lg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQyMyI+NDIzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBUYWJsZSBmb290ZXIgcmVuZGVyaW5nIHN1cHBvcnQsIHNvIHRoYXQgY29sdW1uIHRvdGFscyBjYW4gYmUgcmVuZGVyZWQgaW4gYSB0YWJsZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQyNSI+NDI1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBUYWJsZSByZW5kZXJpbmcgcGVyZm9ybWFuY2UgaW4gdGhlIG9yZGVyIG9mIDI1LTQ1JS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIHJlbmRlcmluZyBwZXJmb3JtYW5jZSBieSBjYWNoaW5nIHRoZSBDbGlja1V0aWxzIA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCNnZXRSZXNvdXJjZVZlcnNpb25JbmRpY2F0b3Iob3JnLmFwYWNoZS5jbGljay5Db250ZXh0KSI+cmVzb3VyY2UgdmVyc2lvbiBpbmRpY2F0b3I8L2E+DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDEyIj40MTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIFBhZ2UgYW5kIFBhZ2VJbXBvcnRzIHRvIGFsbG93IGEgUGFnZXMgdG8gb3B0aW1pemUgdGhlaXIgSFRNTCBpbXBvcnRzLg0KICAgICAgICBQbGVhc2Ugc2VlIENsaWNrIEV4YW1wbGVzIGZvciBhIGRlbW9uc3RyYXRpb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNjMiPjM2MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgaXNzdWUgd2hlcmUgU2VsZWN0IHZhbGlkYXRpb24gY2FuIHRocm93IENsYXNzQ2FzdEV4Y2VwdGlvbiANCiAgICAgICAgd2hlbiBvcHRpb24gbGlzdCBjb250YWlucyBhbiBPcHRpb25Hcm91cC4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllciBieSBDaHJpc3RvcGhlIEZvaXJldA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM3NCI+Mzc0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBpc3N1ZSB3aGVyZSBDb250YWluZXIgY2FuIGJlIGFkZGVkIHRvIGl0c2VsZi4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllciBieSBIYXJyeSBXaXNzaWFrDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDE0Ij40MTQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFBhZ2Ugc2VyaWFsaXphdGlvbiBpc3N1ZXMgd2l0aCBub24gc2VyaWFsaXphYmxlIEZvcm1hdCBhbmQgUGFnZUltcG9ydCBvYmplY3RzLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVyIGJ5IEFsZXhlaSBTb2tvbG92DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDE2Ij40MTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIGlzc3VlIHdoZXJlIENheWVubmVGb3JtIGNsZWFyVmFsdWVzKCkgd2FzIGhpZGRlbiBkYXRhIG9iamVjdCBjbGFzc25hbWUuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZXIgYnkgV2lza2luZyBKdSBZdSBXdQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQxNyI+NDE3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBpc3N1ZSB3aGVyZSBUYWJiZWRQYW5lbCB3YXMgaW52b2tpbmcgdGhlIGFjdGl2ZVBhbmVsJ3Mgb25Jbml0KCkgbWV0aG9kIHR3aWNlLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVyIGJ5IFdpc2tpbmcgSnUgWXUgV3UNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MjAiPjQyMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8ZHQ+PGEgbmFtZT0iMS41LU0yIj48L2E+RGV2ZWxvcG1lbnQgUmVsZWFzZSAtIFZlcnNpb24gMS41IE0yIC0gMjAgSnVseSAyMDA4PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4gDQogICAgSU1QT1JUQU5UIGJlIHN1cmUgdG8gcmVhZCB0aGUgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjMS41Ij51cGdyYWRlIHBhdGg8L2E+IHdoZW4gdXBncmFkaW5nIGZyb20gQ2xpY2sgMS40IG9yIGVhcmxpZXIuDQogICAgPHAvPg0KICAgIENsaWNrIDEuNSBNMiBpbnRyb2R1Y2VkIG1ham9yIGVuaGFuY2VtZW50cyB0byBDb250cm9sIGxpc3RlbmVyIHN1cHBvcnQuDQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBOZXcgQ29udHJvbCBsaXN0ZW5lciBzdXBwb3J0IHRocm91Z2ggdGhlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0FjdGlvbkxpc3RlbmVyLmh0bWwiPkFjdGlvbkxpc3RlbmVyPC9hPiBpbnRlcmZhY2UuDQogICAgICAgIFRoaXMgY29udHJvbCBsaXN0ZW5lciBzdHlsZSBwcm92aWRlcyBjb21waWxlIHRpbWUgc2FmZXR5IGFuZCBzdXBwb3J0cyBjb2RlIHJlZmFjdG9yaW5nIHRvb2xzLg0KICAgICAgICANCiAgICAgIDxwcmUgY2xhc3M9InByZXR0eXByaW50Ij4NCnB1YmxpYyBjbGFzcyBNeVBhZ2UgZXh0ZW5kcyBQYWdlIHsNCg0KICAgIHB1YmxpYyB2b2lkIG9uSW5pdCgpIHsNCiAgICAgICAgU3VibWl0IHN1Ym1pdCA9IG5ldyBTdWJtaXQoInN1Ym1pdCIpOw0KICAgICAgICANCiAgICAgICAgc3VibWl0LnNldEFjdGlvbkxpc3RlbmVyKG5ldyBBY3Rpb25MaXN0ZW5lcigpIHsNCiAgICAgICAgICAgIHB1YmxpYyBib29sZWFuIG9uQWN0aW9uKENvbnRyb2wgc291cmNlKSB7DQogICAgICAgICAgICAgICAgLy8gUGVyZm9ybSBzdWJtaXQgYWN0aW9uIGFuZCByZXR1cm4gdHJ1ZSB0byBjb250aW51ZSBwcm9jZXNzaW5nDQogICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7DQogICAgICAgICAgICB9DQogICAgICAgIH0pOw0KICAgIH0NCn0gPC9wcmU+DQogICAgICBOb3RlIHRoYXQgdGhlIHNvdXJjZSBDb250cm9sIGlzIHBhc3NlZCBpbiBhcyBhbiBhcmd1bWVudCB0byB0aGUgb25BY3Rpb24gbWV0aG9kLiANCiAgICAgIEZvciB2ZXJ5IGNvbXBsZXggc2NlbmFyaW9zIGl0IGlzIHVzZWZ1bCB0byBrbm93IHdoaWNoIENvbnRyb2wgdHJpZ2dlcmVkIHRoZSBldmVudA0KICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNjkiPjM2OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW50cm9kdWNlIGEgdHdvIHBoYXNlIGxpc3RlbmVyIGRpc3BhdGNoIG1lY2hhbmlzbS4gRHVyaW5nIHRoZSBvblByb2Nlc3MgZXZlbnQsDQogICAgICAgIENvbnRyb2wgbGlzdGVuZXJzIHdpbGwgYmUgcmVnaXN0ZXJlZCBvbiB0aGUgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQWN0aW9uRXZlbnREaXNwYXRjaGVyLmh0bWwiPkFjdGlvbkV2ZW50RGlzcGF0Y2hlcjwvYT4NCiAgICAgICAgYW5kIHRyaWdnZXJlZCBhZnRlciB0aGUgb25Qcm9jZXNzIGV2ZW50IGZpbmlzaC4gVGhlIG5ldCBlZmZlY3Qgb2YgdGhpcyBjaGFuZ2UNCiAgICAgICAgaXMgdGhhdCB3aGVuIENvbnRyb2wgbGlzdGVuZXJzIGFyZSB0cmlnZ2VyZWQsIGFsbCByZXF1ZXN0IHZhbHVlcyBoYXZlIGJlZW4gYm91bmQgdG8gQ29udHJvbHMsDQogICAgICAgIGFuZCBjYW4gc2FmZWx5IGJlIHJlZmVycmVkIHRvIGZyb20gdGhlIGxpc3RlbmVyIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzY1Ij4zNjU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGJ1dHRvbiBzdXBwb3J0IHRvIEZpZWxkU2V0LCBzbyB0aGF0IGJ1dHRvbnMgY2FuIGJlIHJlbmRlcmVkIGluc2lkZQ0KICAgICAgICBGaWVsZFNldHMuIFRoaXMgY2hhbmdlIGhhcyBiZWVuIGVuYWJsZWQgYnkgdHdvIHBoYXNlIHByb2Nlc3Npbmcgd2hpY2gNCiAgICAgICAgZW5zdXJlcyBhbGwgRmllbGRTZXQgZmllbGRzIGFyZSBwcm9jZXNzZWQgYmVmb3JlIGJ1dHRvbiBsaXN0ZW5lcnMgYXJlIGludm9rZWQNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MDEiPjQwMTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgPC91bD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+IA0KICAgIFRoZSBmb2xsb3dpbmcgaXMgYSBsaXN0IG9mIGVuaGFuY2VtZW50cyBhbmQgYnVncyBmaXhlczogDQogICAgPC9kaXY+DQoJPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBhIG5ldyA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUGFnZUJ1dHRvbi5odG1sIj5QYWdlQnV0dG9uPC9hPiBjb250cm9sDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzkyIj4zOTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEludHJvZHVjZWQgYSBuZXcgcmVzb3VyY2UgZGVwbG95bWVudCBzdHJhdGVneSBmb3IgPGVtPkphcnM8L2VtPiBjb250YWluaW5nDQogICAgICAgIFBhZ2UgYW5kIENvbnRyb2wgcmVzb3VyY2VzLiBXaGVuIENsaWNrIHN0YXJ0cyB1cCwgaXQgc2NhbnMgZWFjaCBKYXIgZm91bmQNCiAgICAgICAgaW4gdGhlIHdlYiBsaWIgZm9sZGVyICh3ZWJhcHAvV0VCLUlORi9saWIpIGZvciBlbnRyaWVzIHN0YXJ0aW5nIHdpdGggJ01FVEEtSU5GL3dlYi8nLg0KICAgICAgICBBbGwgZmlsZXMgZm91bmQgdW5kZXIgJ01FVEEtSU5GL3dlYi8nIHdpbGwgYmUgY29waWVkIHZlcmJhdGltIHRvIHRoZSB3ZWINCiAgICAgICAgYXBwbGljYXRpb24gZm9sZGVyLg0KICAgICAgICA8cC8+DQogICAgICAgIFNlZSB0aGUgc2VjdGlvbiA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMy5odG1sI2RlcGxveWluZy1jdXN0b20tcmVzb3VyY2VzIj5EZXBsb3lpbmcgQ3VzdG9tIFJlc291cmNlczwvYT4NCiAgICAgICAgZm9yIG1vcmUgZGV0YWlsLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM5MyI+MzkzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGQgbmV3IG1ldGhvZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvQ2hlY2tib3hUcmVlLmh0bWwjc2V0U2VsZWN0Q2hpbGROb2Rlcyhib29sZWFuKSI+Q2hlY2tib3hUcmVlLnNldFNlbGVjdENoaWxkTm9kZXM8L2E+DQogICAgICAgIHRoYXQgZW5hYmxlcyBzZWxlY3RpbmcgY2hpbGQgbm9kZXMgd2hlbiBwYXJlbnQgaXMgc2VsZWN0ZWQuIFRoaXMgZmVhdHVyZQ0KICAgICAgICBvbmx5IHdvcmtzIGlmIHRoZSBUcmVlJ3MgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL1RyZWUuaHRtbCNzZXRKYXZhc2NyaXB0RW5hYmxlZChib29sZWFuKSI+SmF2YXNjcmlwdDwvYT4NCiAgICAgICAgc3VwcG9ydCBpcyBlbmFibGVkLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIwOSI+MjA5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBwcm9wZXJ0eSBmaWxlcyB3aXRoIHRyYW5zbGF0aW9uIGZvciB0aGUgUm9tYW5pYW4gbGFuZ3VhZ2UuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgTWFyaXVzIFBldHJ1cw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM2MSI+MzYxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGQgd2lkdGggc3VwcG9ydCB0byBUYWJiZWRQYW5lbCBjb250cm9sDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzc2Ij4zNzY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZCBzdGF0aWMgbWV0aG9kIENvbnRleHQuaGFzVGhyZWFkTG9jYWxDb250ZXh0KCkuDQogICAgICAgIFVzZWZ1bCBmb3IgY2hlY2tpbmcgaWYgYSBDb250ZXh0IGlzIGF2YWlsYWJsZSBvbiB0aGUgQ29udGV4dCBzdGFjaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM4MiI+MzgyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGQgQ2xpY2tVdGlscyBhdXRvUG9zdFJlZGlyZWN0KCkgbWV0aG9kIHRvIHN1cHBvcnQgDQogICAgICAgIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9lbi53aWtpcGVkaWEub3JnL3dpa2kvU0FNTCI+U0FNTDwvYT4NCiAgICAgICAgaW50ZWdyYXRpb24NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zOTgiPjM5ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJVXBkYXRlZCBDb250YWluZXIgcmVuYW1pbmcgbWV0aG9kIENvbnRhaW5lci5hZGQoaW50LCBDb250cm9sKSB0byBDb250YWluZXIuaW5zZXJ0KENvbnRyb2wsIGludCkgDQoJCXRvIGJldHRlciByZWZsZWN0IHRoZSBpbnRlbnRpb24NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zODEiPjM4MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlIEZvcm0gdG8gdXNlIGNvbnRyb2wgbWVzc2FnZSBidW5kbGVzIGZvciBsYWJlbCByZXF1aXJlZCBwcmVmaXgvc3VmZml4DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzgzIj4zODM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZSBIdG1sU3RyaW5nQnVmZmVyIHRvIHN1cHBvcnQgbWV0aG9kIGNoYWluaW5nLiANCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERlbWV0cmlvcyBLeXJpYWtpcw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM5NiI+Mzk2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIE1lbnUgc28gdGhhdCBpdCBpcyBub3cgb25seSBjYWNoZWQgaW4gcHJvZHVjdGlvbiBvciBwcm9maWxlIG1vZGVzLiANCiAgICAgICAgSW4gb3RoZXIgZGV2ZWxvcG1lbnQgbW9kZXMsIGNoYW5nZXMgdG8gbWVudS54bWwgaXMgc2VlbiBpbW1lZGlhdGVseS4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MDgiPjQwODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBBYnN0cmFjdENvbnRhaW5lckZpZWxkIGNvbnRyb2wgbW92aW5nIGl0IHRvIENsaWNrIEV4dHJhcy4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MTAiPjQxMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgVGFiYmVkUGFuZWwgYnVnIHdoZXJlYnkgaW5hY3RpdmUgcGFuZWwgSFRNTCBpbXBvcnRzIGFyZSBpbmNsdWRlZCBpbiBwYWdlDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzY2Ij4zNjY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIEZpZWxkU2V0IHJlY3Vyc2l2ZSByZW1vdmUgYnVnDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzY3Ij4zNjc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIGJ1ZyB3aGVuIG1hbnVhbGx5IGludmFsaWRhdGluZyBIdHRwU2Vzc2lvbg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM3MSI+MzcxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBQcm9wZXJ0eVNlbGVjdCBhZGQgb3JkZXJpbmcgdG8gcXVlcnkgYnVnDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzcyIj4zNzI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIG1lc3NhZ2UgcHJvcGVydGllcyB0byByZXNvbHZlIGFsbCBwYXJlbnQgbWVzc2FnZXMNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNzMiPjM3MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgTGFiZWxzIG5vdCByZW5kZXJpbmcgaW4gYSBGaWVsZFNldCBidWcNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNzciPjM3NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRm9ybSByZW1vdmVGaWVsZCB0aHJvd3MgSWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uIGJ1Zw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM3OCI+Mzc4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBGaWVsZFNldCByZXN0b3JpbmcgRmllbGRTZXQgYWJpbGl0eSB0byBzZXQgbnVtYmVyIG9mIHRhYmxlIGNvbHVtbnMgDQoJCXRoZSBGaWVsZFNldCBpcyByZW5kZXJlZCB3aXRoDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzc5Ij4zNzk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIGJ1ZyB3aGVyZSBGb3JtYXQgaXMgbm90IGF2YWlsYWJsZSBpbiB0ZW1wbGF0ZSBvZiBzdGF0ZWZ1bCBwYWdlcy4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MDkiPjQwOTwvYT5dLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8ZHQ+PGEgbmFtZT0iMS41LU0xIj48L2E+RGV2ZWxvcG1lbnQgUmVsZWFzZSAtIFZlcnNpb24gMS41IE0xIC0gMTggTWF5IDIwMDg8L2R0Pg0KICA8ZGQ+DQogICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgSU1QT1JUQU5UIGJlIHN1cmUgdG8gcmVhZCB0aGUgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjMS41Ij51cGdyYWRlIHBhdGg8L2E+IHdoZW4gdXBncmFkaW5nIGZyb20gYSBwcmV2aW91cyB2ZXJzaW9uLg0KICAgIDxwLz4NCiAgICBDbGljayAxLjUgKGN1cnJlbnRseSBpbiBkZXZlbG9wbWVudCkgaW50cm9kdWNlcyBpbXBvcnRhbnQgbmV3IGZlYXR1cmVzIGluY2x1ZGluZzoNCiAgICA8cC8+DQogICAgPHVsIHN0eWxlPSJtYXJnaW4tdG9wOjAuNWVtOyI+DQogICAgIDxsaSBjbGFzcz0iaXRlbSI+PGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDNzMDYuaHRtbCI+Q29udGFpbmVyPC9hPiAtIG5ldyBpbnRlcmZhY2UgZm9yIGJ1aWxkaW5nIGFyYml0cmFyeSBjb21wbGV4LCBoaWVyYXJjaGljYWwgQ29udHJvbHMuPC9saT4NCiAgICAgPGxpIGNsYXNzPSJpdGVtIj48YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9zZXJ2aWNlL3BhY2thZ2Utc3VtbWFyeS5odG1sI3NlcnZpY2VzIj5TZXJ2aWNlczwvYT4gLSBDbGljayBjb3JlIGhhcyBiZWVuIHJlZmFjdG9yZWQgaW50byBwbHVnZ2FibGUgc2VydmljZXMuPC9saT4NCiAgICAgPGxpIGNsYXNzPSJpdGVtIj48YSBocmVmPSJtb2NrLWFwaS9vdmVydmlldy1zdW1tYXJ5Lmh0bWwiPk1vY2sgVGVzdCBTdXBwb3J0PC9hPiAtIFVuaXQgYW5kIEZ1bmN0aW9uYWwgVGVzdGluZy48L2xpPg0KICAgICA8bGkgY2xhc3M9Iml0ZW0iPjxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWJzdHJhY3RDb250cm9sLmh0bWwiPkFic3RyYWN0Q29udHJvbDwvYT4NCiAgICAgLSBBYnN0cmFjdENvbnRyb2wgd2FzIGV4dGVuZGVkIHRvIGltcGxlbWVudCBhbGwgQ29udHJvbCBtZXRob2RzLCBtYWtpbmcgaXQgZWFzaWVyIHRvIGNyZWF0ZSBjdXN0b20gY29udHJvbHMuPC9saT4NCiAgICA8L3VsPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6MS41ZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICBOZXcgZXhhbXBsZXMgYW5kIGRvY3VtZW50YXRpb24gd2VyZSBhZGRlZDoNCiAgICA8L2Rpdj4NCiAgICA8dWw+DQogICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5OZXcgZXhhbXBsZXM6DQogICAgICA8dWwgc3R5bGU9InBhZGRpbmctdG9wOiA1cHg7Ij4NCiAgICAgICAgICA8bGk+DQogICAgICAgICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2Zvcm0vZXh0cmEtY29udHJvbHMtZm9ybS5odG0iPkNvdW50cnkgU2VsZWN0IGZpZWxkPC9hPg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICA8bGk+DQogICAgICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvZm9ybS9jb250YWN0LWRldGFpbHMuaHRtIj5DdXN0b20gRm9ybSBMYXlvdXQgdXNpbmcgQ29udGFpbmVyczwvYT4NCiAgICAgICAgIDwvbGk+DQogICAgICAgICA8bGk+DQogICAgICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvZm9ybS9leHRyYS1jb250cm9scy1mb3JtLmh0bSI+VmlydHVhbCBLZXlib2FyZCBmaWVsZDwvYT4NCiAgICAgICAgIDwvbGk+DQogICAgICAgICA8bGk+DQogICAgICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvZ2VuZXJhbC9leGNlbC1leHBvcnQuaHRtIj5FeGNlbCBFeHBvcnQgRGVtbzwvYT4NCiAgICAgICAgIDwvbGk+DQogICAgICAgICA8bGk+DQogICAgICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvanNwL2VkaXQtY3VzdG9tZXIuaHRtIj5KU1AgLSBFZGl0IEN1c3RvbWVyPC9hPg0KICAgICAgICAgPC9saT4NCiAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9qc3AvbmF2aWdhdGlvbi1hLmh0bSI+SlNQIC0gTmF2aWdhdGlvbjwvYT4NCiAgICAgICAgIDwvbGk+DQogICAgICAgICA8bGk+DQogICAgICAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvanNwL211bHRpLXBhdGgtZGVtby5odG0iPkpTUCAtIE11bHRpIFBhdGggRGVtbzwvYT4NCiAgICAgICAgIDwvbGk+DQogICAgICA8L3VsPg0KICAgICA8L2xpPg0KICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+TmV3IGRvY3VtZW50YXRpb246DQogICAgIDx1bCBzdHlsZT0icGFkZGluZy10b3A6IDVweDsiPg0KICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAzczA2Lmh0bWwjY29udGFpbmVyIj5Db250YWluZXI8L2E+DQogICAgICAgICA8L2xpPg0KICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAzczA3Lmh0bWwjbGF5b3V0Ij5UZW1wbGF0ZSB2cyBDb250YWluZXIgbGF5b3V0PC9hPg0KICAgICAgICAgPC9saT4NCiAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9zZXJ2aWNlL3BhY2thZ2Utc3VtbWFyeS5odG1sIj5DbGljayBSdW50aW1lIFNlcnZpY2VzPC9hPg0KICAgICAgICAgPC9saT4NCiAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICA8YSBocmVmPSJtb2NrLWFwaS9vdmVydmlldy1zdW1tYXJ5Lmh0bWwiPk1vY2sgVGVzdCBTdXBwb3J0PC9hPg0KICAgICAgICAgPC9saT4NCiAgICAgPC91bD4NCiAgICA8L2xpPg0KICAgPC91bD4NCiAgPC9kaXY+DQogIDxwLz4NCiAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tdG9wOjEuNWVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICBBIG5ldyA8YSBocmVmPSJjbGljay1vbmxpbmUuaHRtbCNwb3dlcmVkIj5Qb3dlcmVkIGJ5IENsaWNrPC9hPiBzZWN0aW9uIHdhcyBhZGRlZC4NCiAgIElmIHlvdSB3YW50IHRvIGVubGlzdCB5b3VyIHNpdGUsIHBsZWFzZSBzZW5kIGEgbWFpbCB0byBvbmUgb2Ygb3VyIA0KICAgPGEgaHJlZj0iY2xpY2stb25saW5lLmh0bWwjbWFpbGluZy1saXN0cyI+TWFpbGluZyBMaXN0czwvYT4gb3IgZGlyZWN0bHkgdG8gInNhYm9iMSBhdCBnbWFpbC5jb20iLg0KICAgPHAvPg0KICAgVGhlIGZvbGxvd2luZyBpcyBhIGxpc3Qgb2YgZW5oYW5jZW1lbnRzIGFuZCBidWdzIGZpeGVzOg0KICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIEFkZGVkIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly93d3cuZnJlZW1hcmtlci5vcmciPkZyZWVtYXJrZXI8L2E+IHN1cHBvcnQgYXMgYW4gDQoJICAgIGFsdGVybmF0aXZlIHRlbXBsYXRpbmcgZW5naW5lIHRvIFZlbG9jaXR5LCB3aXRoIG5ldyANCgkgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9zZXJ2aWNlL0ZyZWVtYXJrZXJUZW1wbGF0ZVNlcnZpY2UuaHRtbCI+RnJlZW1hcmtlclRlbXBsYXRlU2VydmljZTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCSAgICBBZGRlZCBhIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9Db3VudHJ5U2VsZWN0Lmh0bWwiPkNvdW50cnkgU2VsZWN0PC9hPg0KCSAgICBjb250cm9sIGJhc2VkIG9uIHRoZSBKREsncyBvd24gYnVpbHQgaW4gQ291bnRyeS9Mb2NhbGUgc3VwcG9ydC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIEFkZGVkIGEgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL1ZpcnR1YWxLZXlib2FyZC5odG1sIj5WaXJ0dWFsIEtleWJvYXJkPC9hPiANCgkgICAgY29udHJvbCB1c2luZyA8YSBocmVmPSJodHRwOi8vd3d3LmdyZXl3eXZlcm4uY29tL2NvZGUvanMva2V5Ym9hcmQuaHRtbCI+R3JleVd5dmVybjwvYT4gSmF2YVNjcmlwdCBsaWJyYXJ5Lg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgQWRkZWQgc3VwcG9ydCBmb3Igc2V0dGluZyBGb3JtICANCgkgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjZ2V0QWN0aW9uVVJMKCkiPmFjdGlvbjwvYT4gDQoJICAgIFVSTCBhdHRyaWJ1dGUuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBFcmRlbSBHdW5heQ0KCSAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxOSI+MzE5PC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCSAgICBBZGRlZCBzdXBwb3J0IGZvciBQYWdlIEhUTUwJaW1wb3J0cyB3aXRoIGEgbmV3IDx0dD5nZXRIdG1sSW1wb3J0cygpPC90dD4gDQoJICAgIG1ldGhvZC4gVGhpcyBlbmFibGVzIFBhZ2VzIHRvIHByb2dyYW1tYXRpY2FsbHkgZGVmaW5lIEhUTUwgaW1wb3J0cyB3aGljaA0KCSAgICB3aWxsIGJlIGluY2x1ZGVkIGluIGEgYm9yZGVyIHRlbXBsYXRlIHVzaW5nIHRoZSBQYWdlSW1wb3J0cyBvYmplY3QuDQoJICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEYXZpZCBGcml6ZWxsZQ0KCSAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyOSI+MzI5PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGQgUGFnZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0VGVtcGxhdGUoamF2YS5sYW5nLlN0cmluZykiPnNldFRlbXBsYXRlKFN0cmluZyk8L2E+DQogICAgICAgIG1ldGhvZCB0byBlbmFibGUgZHluYW1pYyBjaGFuZ2luZyBvZiBhIHBhZ2UgYm9yZGVyIHRlbXBsYXRlLiBUaGlzIGlzc3VlDQogICAgICAgIHdhcyByYWlzZWQgYnkgSHV5IERvIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM1MyI+MzUzPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzZXRQYXRoKGphdmEubGFuZy5TdHJpbmcpIj5QYWdlLnNldFBhdGg8L2E+IHRvIGhhbmRsZSBKU1AgcmVzb3VyY2VzLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEh1eSBEby4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNDEiPjE0MTwvYT5dLg0KCSAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgSGliZXJuYXRlIEFubm9jYXRpb25Db25maWd1cmF0aW9uLiBUaGlzIGlzc3VlIHdhcyBmaXhlZCBieSBKZWFuLUZyYW5jb2lzLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM1NSI+MzU1PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXByb3ZlZCBGaWxlVXBsb2FkIHN1cHBvcnQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMjYiPjMyNjwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wcm92ZSBGaWxlIFVwbG9hZCBzdXBwb3J0IHdpdGggbmV3IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvRmlsZVVwbG9hZFNlcnZpY2UuaHRtbCI+RmlsZVVwbG9hZFNlcnZpY2U8L2E+IGNsYXNzLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyNiI+MzI2PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBQcm9wZXJ0eVNlbGVjdCB3aGljaCBpcyBub3QgcmVzZXQgdG8gb3JpZ2luYWwgdmFsdWUuIFRoaXMgaXMgd2FzIHJhaXNlZCBieSBUb3JlIEhhbHNldA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxNyI+MzE3PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDYXllbm5lIDMuME0zIERhdGFPYmplY3RVdGlscyBpc3N1ZSBpbiBDYXllbm5lRm9ybSB3aGVuIHVzaW5nIEpESyAxLjUuIA0KICAgICAgICBBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvQ2F5ZW5uZVV0aWxzLmh0bWwiPkNheWVubmVVdGlsczwvYT4gaGVscGVyIGNsYXNzDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQyIj4zNDI8L2E+XS4NCgkgIDwvbGk+DQogICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICBVcGdyYWRlZCB0aGUgZm9sbG93aW5nIGxpYnJhcmllczoNCiAgICAgPHVsIHN0eWxlPSJtYXJnaW4tdG9wOjFlbTsiPg0KICAgICAgIDxsaT5jb21tb25zLWxhbmcgMi4xIC0+IGNvbW1vbnMtaW8gMi40PC9saT4NCiAgICAgICA8bGk+Y29tbW9ucy1pbyAxLjMgLT4gY29tbW9ucy1pbyAxLjQ8L2xpPg0KICAgICAgIDxsaT5jb21tb25zLWZpbGV1cGxvYWQgMS4yIC0+IGNvbW1vbnMtZmlsZXVwbG9hZCAxLjIuMTwvbGk+DQogICAgICAgPGxpPkhpYmVybmF0ZSAzLjEuMyAtPiBIaWJlcm5hdGUgMy4yLjY8L2xpPg0KICAgICAgIDxsaT5TcHJpbmcgMS4yLjkgLT4gU3ByaW5nIDIuNS40PC9saT4NCiAgICAgPC91bD4NCiAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPlJlbW92ZWQgc3VwcG9ydCBmb3IgQ2F5ZW5uZSAxLjIueC48L2xpPg0KICAJPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+PGEgbmFtZT0iMS40LjIiPjwvYT5WZXJzaW9uIDEuNC4yIC0gMTIgQXByaWwgMjAwODwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIEV4Y2x1ZGVQYWdlIHNob3VsZCBiZSBhIHB1YmxpYyBjbGFzcw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM0NiI+MzQ2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBNYXZlbiBhcnRpZmFjdHMgcGFja2FnaW5nDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQ4Ij4zNDg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIHNsaWdodCBwZXJmb3JtYW5jZSBkZWdyYWRhdGlvbg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM0OSI+MzQ5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIFBhZ2VMaW5rIHRvIGNoYW5nZSBleHRlbnNpb24gPHR0PmpzcDwvdHQ+IHRvIDx0dD5odG08L3R0Pg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM1MiI+MzUyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIERhdGVGaWVsZCBhbmQgQ2hhcnRGaWVsZHMgdG8gaW5jbHVkZSB0aGUgamF2YXNjcmlwdCA8dHQ+Y29udHJvbC5qczwvdHQ+DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzU0Ij4zNTQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgRGF0ZUZpZWxkIHdoaWNoIHByb2R1Y2VkIGR1cGxpY2F0ZSBzdHlsZXNoZWV0IGxpbmtzLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM1NiI+MzU2PC9hPl0uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxkdD48YSBuYW1lPSIxLjQuMSI+PC9hPlZlcnNpb24gMS40LjEgLSAzMCBNYXJjaCAyMDA4PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4gRGV2ZWxvcGVyDQogICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9zYWJvYi8iPkJvYiBTY2hlbGxpbms8L2E+DQogICAgYWNjZXB0cyBuZXcgUHJvamVjdCBMZWFkZXIgcm9sZSBmb3IgdGhlIENsaWNrIHByb2plY3QuPGJyLz4NCiAgICBOZXcgZGV2ZWxvcGVyIDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9InJpY2FyZG9sZWNoZXRhQHVzZXJzLnNvdXJjZWZvcmdlLm5ldCI+UmljYXJkbyBMZWNoZXRhPC9hPiBqb2lucyB0aGUgQ2xpY2sgcHJvamVjdC4NCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG5ldyBtZXRob2QgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI2lzQWpheFJlcXVlc3QoKSI+Q29udGV4dC5pc0FqYXhSZXF1ZXN0KCk8L2E+DQogICAgICAgIHdoaWNoIGVuYWJsZXMgY29uZGl0aW9uYWwgY2hlY2tpbmcgZm9yIEFqYXggcmVxdWVzdHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlVcGdyYWRlZGVkIHRvIFNjcmlwdGFjdWxvdXMgMS44LjEgdG8gZml4IGF1dG8gZm9ybSBzdWJtaXQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBbmR5IEtleS4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMzYiPjMzNjwvYT5dLg0KCSAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgZGVwbG95bWVudCBvZiByZXNvdXJjZXMgd2hlbiBzZXJ2bGV0IGNvbnRhaW5lciBkb2VzIG5vdCB1bnBhY2sgd2FyLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM0MCI+MzQwPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBzZW5kUmVkaXJlY3QgdG8gY29udmVydCA8ZW0+LmpzcDwvZW0+IGV4dGVuc2lvbiB0byA8ZW0+Lmh0bTwvZW0+IHdoZW4gcmVkaXJlY3RpbmcgdG8gYSBKU1AgcGFnZS4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMzgiPjMzODwvYT5dLg0KCSAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRm9ybSA8dHQ+Y2xlYXJWYWx1ZXMoKTwvdHQ+IHRvIGV4Y2x1ZGUgY2VydGFpbiBIaWRkZW5GaWVsZHMgZnJvbSBiZWluZyBjbGVhcmVkLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMzNyI+MzM3PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBGb3JtIGFjdGlvbiBpbmNvcnJlY3Qgd2hlbiB1c2luZyBKU1AuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBDaGFzIEVyaWNrc29uLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMzNCI+MzM0PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNvblN1Ym1pdENoZWNrKG9yZy5hcGFjaGUuY2xpY2suUGFnZSwgamF2YS5sYW5nLlN0cmluZykiPkZvcm0ub25TdWJtaXRDaGVjaygpPC9hPg0KICAgICAgICB0byBpZ25vcmUgQWpheCBjYWxscy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEl2YW4gRnVyZGkuDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzMzIj4zMzM8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIEZvcm0gYW5kIEZpZWxkU2V0IGNvbHVtbiBsYXlvdXQgYnVnIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMzMSI+MzMxPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBUYWJsZSBjb2x1bW4gc29ydGluZyBpc3N1ZSB3aXRoIHN0cmluZyB2YWx1ZXMuIA0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQmVuIFlvdW5nDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQ0Ij4zNDQ8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFRhYmxlIHN0eWxlIGlzc3VlcyB3aXRoIHNvcnRlZCBjb2x1bW5zIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM0NSI+MzQ1PC9hPl0uDQoJICA8L2xpPg0KICAJPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+PGEgbmFtZT0iMS40Ij48L2E+VmVyc2lvbiAxLjQgLSAyIE1hcmNoIDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlVcGRhdGVkIENheWVubmUgY29udHJvbHMgdG8gc3VwcG9ydCBDYXllbm5lIHZlcnNpb24gMy4wLg0KCSAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ2F5ZW5uZUZvcm0gPHR0PnNhdmUoKTwvdHQ+IG1ldGhvZCBpbnNlcnRpbmcgbXVsdGlwbGUgbmV3IGVudHJpZXMgYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIFRvcmUgSGFsc2V0DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzA3Ij4zMDc8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFRhYmxlIGludmFsaWQgaGFuZGxpbmcgcGFyYW1zIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBTYXRvc2hpIFRha2F0YQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMwOCI+MzA4PC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBEYXRlRmllbGQgcmVhZG9ubHkgSmF2YVNjcmlwdCBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBUb3JlIEhhbHNldA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMwOSI+MzA5PC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBEYXRlRmllbGQgRHV0Y2ggQ2FsZW5kYXIgdHJhbnNsYXRpb24uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBIYXJyeSBXaXNzaWFrDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzEwIj4zMTA8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIERhdGVGaWVsZCA8dHQ+JGltcG9ydHM8L3R0PiB1c2FnZSBKYXZhU2NyaXB0IGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEl0b3UgQWtpaGlybw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxMSI+MzExPC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBidWcgd2hlcmUgY2hhcnNldCBlbmNvZGluZyBiZWluZyBzZXQgYWZ0ZXIgcmVxdWVzdCBwYXJhbWV0ZXJzIGFyZSByZWFkLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxMiI+MzEyPC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBUaHJlYWRMb2NhbCBDb250ZXh0IGZvcndhcmRpbmcgYnVnIG9uIEpldHR5IDUuMS4qLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUmljYXJkbyBMZWNoZXRhDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzE0Ij4zMTQ8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkICdzY3JpcHQuYWN1bG8udXMnIEFqYXguQXV0b2NvbXBsZXRlciBidWcgd2l0aCBJRS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEl0b3UgQWtpaGlybw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyMiI+MzIyPC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBDb21wcmVzc2lvblNlcnZsZXRSZXNwb25zZVdyYXBwZXIgTlBFIGJ1Z3Mgb24gV2ViU3BoZXJlIGFuZCBKZXR0eS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFJpY2FyZG8gTGVjaGV0YSBhbmQgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyMyI+MzIzPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gCSAgDQoJPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjQgUkMzIC0gNiBGZWJydWFyeSAyMDA4PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9maWx0ZXIvUGVyZm9ybWFuY2VGaWx0ZXIuaHRtbCI+UGVyZm9ybWFuY2VGaWx0ZXI8L2E+IA0KCQl0byBzaWduaWZpY2FudGx5IGltcHJvdmUgdGhlIHBlcmZvcm1hbmNlIG9mIENsaWNrIGFwcGxpY2F0aW9ucw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI4NCI+Mjg0PC9hPiwgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI5MCI+MjkwPC9hPl0uDQoJCTxwLz4NCgkJQ2xpY2sgRnJhbWV3b3JrIG5vdyBzdXBwb3J0cyANCgkJPGEgaHJlZj0iaHR0cDovL2RldmVsb3Blci55YWhvby5jb20vcGVyZm9ybWFuY2UvcnVsZXMuaHRtbCI+RXhjZXB0aW9uYWwgUGVyZm9ybWFuY2U8L2E+DQogICAgICAgIGJlc3QgcHJhY3RpY2VzIGZvciBzcGVlZGluZyB1cCB5b3VyIHdlYiBzaXRlLg0KCQlUaGlzIGZpbHRlciBjb21iaW5lZCB3aXRoIGZyYW1ld29yayBjaGFuZ2VzIGVuYWJsZSBDbGljayBhcHBsaWNhdGlvbnMgdG8gZ2V0DQoJCWFuIEdyYWRlIEEgcmF0aW5nIHdpdGggWWFob28ncyBZU2xvdy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAyczA5Lmh0bWwiPlN0YXRlZnVsIFBhZ2VzPC9hPiB0b3BpYyBhbmQNCgkJY29tcGxldGVkIGZyYW1ld29yayBzdXBwb3J0IGZvciBzZXJpYWxpemluZyBzdGF0ZWZ1bCBQYWdlcyBhbmQgdGhlaXIgY29udHJvbHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBuZXcgQUpBWCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvQXV0b0NvbXBsZXRlVGV4dEZpZWxkLmh0bWwiPkF1dG9Db21wbGV0ZVRleHRGaWVsZDwvYT4gd2hpY2ggcHJvdmlkZXMgR29vZ2xlIHN1Z2dlc3Qgc3R5bGUgbG9va3Vwcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG5ldyBUYWJsZSBDU1MgY2xhc3Mgc3R5bGVzOiA8dHQ+Ymx1ZTEsIGJsdWUyLCBvcmFuZ2UxLCBvcmFuZ2UyPC90dD4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCVVwZGF0ZWQgPHR0PkZvcm0uY29weUZyb20oKTwvdHQ+IHRvIGFsaWduIHdpdGggc3BlY2lhbCBNYXAgaGFuZGxpbmcgb2YgPHR0PkZvcm0uY29weVRvKCk8L3R0Pi4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjc4Ij4yNzg8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIFVwZGF0ZWQgRm9ybSBzdWJtaXQgY2hlY2sgdG8gaGFuZGxlIG11bHRpcGxlIGZvcm1zIHBlciBwYWdlLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNzkiPjI3OTwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgVXBkYXRlZCBUYWJsZSB0byBudWxsaWZ5IHJvd0xpc3QgcHJvcGVydHkuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI4MyI+MjgzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIDx0dD5Db250cm9sczwvdHQ+IHRvIHVzZSB0aGUgbmV3IEFQSSANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BYnN0cmFjdENvbnRyb2wuaHRtbCNhZGRTdHlsZUNsYXNzKGphdmEubGFuZy5TdHJpbmcpIj5hZGRTdHlsZUNsYXNzKFN0cmluZyk8L2E+IGFuZA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0Q29udHJvbC5odG1sI3NldFN0eWxlKGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5TdHJpbmcpIj5zZXRTdHlsZShTdHJpbmcsIFN0cmluZyk8L2E+DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjg2Ij4yODY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIFVwZGF0ZWQgSlMgYWRkTG9hZEV2ZW50KCkgdG8gdXNlIFByb3RvdHlwZSBGaXhlZCBleGNlcHRpb24gd2hlbiB1c2luZyA8dHQ+Rm9ybS5vblNlY3VydHlDaGVjazwvdHQ+IGluIGEgc3RhdGVmdWwgZm9ybS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNDUiPjI0NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgVGFibGUgPHR0PmlzaTwvdHQ+IHN0eWxlIHJlbmRlcmluZyBwcm9ibGVtcy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEouRi4gWmFyYW1hDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTk2Ij4xOTY8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIERhdGVGaWVsZCBKYXZhU2NyaXB0IGZvcm1hdCBwYXR0ZXJuIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEl0b3UgQWtpaGlybyBhbmQgZml4ZWQgYnkgSXRvdSBBa2loaXJvIGFuZCBOYW9raSBUYWtlem9lDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjUwIj4yNTA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIEZpeGVkIGV4Y2VwdGlvbiB3aGVuIHVzaW5nIDx0dD5Gb3JtLm9uU2VjdXJ0eUNoZWNrPC90dD4gaW4gYSBzdGF0ZWZ1bCBmb3JtLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSm9lbCBTY2htaWR0DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjY3Ij4yNjc8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFBpY2tMaXN0IG11bHRpcGxlIHNlbGVjdGlvbiBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yODAiPjI4MDwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ29udGV4dCBsZWFrIHVuZGVyIGhlYXZ5IHVzYWdlLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yODIiPjI4MjwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgUGFnZSBhdXRvbWFwcGluZyBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBTZXAgYW5kIFJpY2FyZG8gTGVjaGV0YQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3NyI+Mjc3PC9hPiwNCgkJIDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yOTQiPjI5NDwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgTGludXggUmVzb3VyY2VCdW5kbGUgY2xhc3Nsb2FkaW5nIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFZpY3Rvcg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI5MyI+MjkzPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBUcmVlIGVuY29kZVVSTCBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgVGhvbWFzIEJlcm5oYXJkDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzAxIj4zMDE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFRhYmxlIG1lbW9yeSBhbGxvY2F0aW9uIGJ1ZyBmb3IgbGFyZ2UgcGFnZWQgcm93TGlzdHMuDQoJCVRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgTmFva2kgVGFrZXpvZQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMwNSI+MzA1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDIuMC40LCB3aGljaCBmaXhlcyBhIG1lbW9yeSBsZWFrIGluIA0KICAgICAgICB2ZXJzaW9uIDIuMDMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBCb2IgU2NoZWxsaW5rIA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI4MSI+MjgxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIHRoZSBKYXZhU2NyaXB0IFByb3RvdHlwZSBsaWJyYXJ5IHRvIHZlcnNpb24gMS41LjAgYW5kICdzY3JpcHQuYWN1bG8udXMnIHRvIHZlcnNpb24gMS43LjAuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjQgUkMyIC0gMiBKYW51YXJ5IDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBwcm9wZXJ0eSBmaWxlcyB3aXRoIHRyYW5zbGF0aW9uIGZvciB0aGUgQ3plY2ggbGFuZ3VhZ2UuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgRGF2aWQgTWFya28NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMzgiPjI0MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgZmFjaWxpdHkgdG8gbG9hZCA8dHQ+Y2xpY2sueG1sPC90dD4gZnJvbSBjbGFzcyBwYXRoIGlmIG5vdCBmb3VuZA0KCQl1c2VyIDx0dD5XRUItSU5GPC90dD4uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQW5kcmUgQnJlbWVyDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjczIj4yNzM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIENhbGVuZGFyIHByb3BlcnR5IGFuZCBKUyBmaWxlcyB3aXRoIHRyYW5zbGF0aW9uIGZvciB0aGUgRHV0Y2ggbGFuZ3VhZ2UuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgSGFycnkgV2lzc2lhaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3NSI+Mjc1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBUYWJsZSBwcm9wZXJ0eSA8dHQ+Y2xlYXJSb3dMaXN0T25EZXN0cm95PC90dD4uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBKb2VsIFNjaG1pZHQNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNjgiPjI2ODwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJVXBkYXRlZCBFeHRlcm5hbExpbmsgY29udHJvbCByZW5hbWluZyBtZXRob2QgPHR0PnNldFBhZ2VDbGFzczwvdHQ+IHRvIDx0dD5zZXRUYXJnZXRQYXRoPC90dD4uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBJdG91IEFraWhpcm8gDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjQ0Ij4yNDQ8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCVVwZGF0ZWQgRmllbGRTZXQgdG8gc3VwcG9ydCByZW5kZXJpbmcgd2l0aG91dCBhIExlZ2VuZC4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEpvZWwgU2NobWlkdA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI1NyI+MjU3PC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlVcGRhdGVkIE1lc3NhZ2VNYXAgdG8gaW1wcm92ZSBjYWNoZSBrZXkuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluayANCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNzQiPjI3NDwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgYnVnIHdoZXJlIGRvdWJsZSAiY2xhc3MiIGF0dHJpYnV0ZXMgYXJlIHJlbmRlcmVkIGluIEhUTUwgZm9yIEZpZWxkIA0KCQljb250cm9scyBpZiB2YWxpZGF0aW9uIGlzIGZhaWxlZC4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIFNodW8gR2VuZyBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluayANCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMzMiPjIzMzwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgdHJhbnNsYXRpb24gZXJyb3JzIGZvciBGcmVuY2ggcHJvcGVydGllcy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBQYXRyaWNrIFRhbGJvdCANCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMzgiPjIzODwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ2xpY2tVdGlscyA8dHQ+Y29weUZvcm1Ub09iamVjdCgpPC90dD4gbWV0aG9kIDx0dD5NYXA8L3R0PiBzdXBwb3J0Lg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSGFycnkgV2lzc2lhayBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluayANCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMzkiPjIzOTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgSlNQIHBhZ2UgcmVjdXJzaW9uIGJ1ZyB3aGVuIG5vdCBib3JkZXIgdGVtcGxhdGUgZGVmaW5lZC4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBSaWNhcmRvIExlY2hldGENCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMzciPjIzNzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRGF0YUNvbnRleHRGaWx0ZXIgYWx3YXlzIGNyZWF0aW5nIEh0dHBTZXNzaW9uIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEZsb3JpbiBULlBBVFJBU0NVDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjQwIj4yNDA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIENsaWNrQXBwIE5QRSBidWcgb24gT0M0SiBhcHBsaWNhdGlvbiBzZXJ2ZXIuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBIYXJyeSBXaXNzaWFrDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjQ4Ij4yNDg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIENvbnRleHQgaGFuZGxpbmcgb2YgbXVsdGl2YWx1ZSBwYXJhbWV0ZXJzIG9uIG11bHRpcGFydCBmaWxlIHVwbG9hZCByZXF1ZXN0cy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNTIiPjI1MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgY2xhc3Nsb2FkZXIgaXNzdWUgd2hlbiBjbGljayBKQVJTIG5vdCBjb250YWluZWQgaW4gd2ViIGFwcGxpY2F0aW9uLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSGFycnkgV2lzc2lhaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI1NiI+MjU2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBtaXNzaW5nIGxhbmd1YWdlIHByb3BlcnRpZXMuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjY5Ij4yNjk8L2E+LA0KCQkgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3MSI+MjcxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBGb3JtVGFibGUgbWlzc2luZyBmaWVsZCBpbXBvcnRzIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEZyYW7nb2lzLVhhdmllciBHdWlsbGVtZXR0ZQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3MiI+Q0xLLTI3MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ2xpY2tVdGlscyA8dHQ+Z2V0TWltaWVUeXBlKCk8L3R0PiBub3Qgc3VwcG9ydGluZyB1cHBlciBjYXNlIGZpbGUgZXh0ZW5zaW9ucy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEJlbiBXYXJuZXINCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNzYiPkNMSy0yNzY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDEuNCBSQzEgLSAxNSBTZXB0ZW1iZXIgMjAwNzwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcG9ydGFudCBDaGFuZ2UNCgkJdGhlIFBhZ2UgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3N0YXRlZnVsIj5zdGF0ZWZ1bDwvYT4gcHJvcGVydHkNCgkJYWRkZWQgdG8gc3VwcG9ydCBwZXJzaXN0ZW5jZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcG9ydGFudCBDaGFuZ2UgDQoJCXRoZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwiPkNvbnRleHQ8L2E+IG9iamVjdA0KCQlpcyBub3cgYXZhaWxhYmxlIGluIFBhZ2UgYW5kIENvbnRyb2wgY29uc3RydWN0b3JzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wb3J0YW50IENoYW5nZSANCgkJYWRkZWQgQ29udHJvbCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwjb25Jbml0KCkiPm9uSW5pdCgpPC9hPiANCgkJaW5pdGlhbGl6YXRpb24gZXZlbnQgaGFuZGxlci4NCgkJQXMgdGhlIDx0dD5zZXRDb250ZXh0KCk8L3R0PiBtZXRob2QgaGFzIGJlZW4NCgkJcmVtb3ZlZCBhbnkgY29udHJvbCBpbml0aWFsaXphdGlvbiBjb2RlIGNvbnRhaW5lZCBpbiB0aGlzIG1ldGhvZCBzaG91bGQgYmUNCgkJbWlncmF0ZWQgdG8gdGhlIG5ldyBjb250cm9sIDx0dD5vbkluaXQoKTwvdHQ+IG1ldGhvZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcG9ydGFudCBDaGFuZ2UgDQoJCXRoZSBYTUwgY29uZmlndXJlZCByb290IE1lbnUgaXRlbSBpcyBvYnRhaW5lZCB2aWEgdGhlIHN0YXRpYyBtZXRob2QgDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9NZW51Lmh0bWwjZ2V0Um9vdE1lbnUoKSI+Z2V0Um9vdE1lbnUoKTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXBvcnRhbnQgQ2hhbmdlIA0KCQltdWx0aXBhcnQgZmlsZSB1cGxvYWQgcmVxdWVzdHMgYXJlIG5vdyBwcm9jZXNzZWQgdXNpbmcgYSBnbG9iYWxseSBjb25maWd1cmVkIENvbW1vbnMgRmlsZVVwbG9hZA0KCQljbGFzcy4gUGxlYXNlIHNlZSB0aGUgDQoJCTxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvQ29tbW9uc0ZpbGVVcGxvYWRTZXJ2aWNlLmh0bWwiPkNvbW1vbnNGaWxlVXBsb2FkU2VydmljZTwvYT4NCgkJZm9yIG1vcmUgZGV0YWlscy4gVGhpcyBjaGFuZ2UgZW5hYmxlcyBmb3IgcmVxdWVzdCBwYXJhbWV0ZXIgYXV0byBiaW5kaW5nDQoJCW9uIG11bHRpcGFydCBmaWxlIHVwbG9hZCByZXF1ZXN0cy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcG9ydGFudCBDaGFuZ2UgDQoJCUNsaWNrIEV4dHJhcyBub3cgc3VwcG9ydHMgQXBhY2hlIENheWVubmUgMi54IHJhdGhlciB0aGFuIE9iamVjdHN0eWxlIENheWVubmUgMS4yLnggDQoJCWJ5IGRlZmF1bHQuIE5vdGUgYmFja3dhcmQgY29tcGF0aWJpbGl0eSBDYXllbm5lIDEuMi54IEpBUlMgYXJlIHByb3ZpZGUgaW4gdGhlIGRpc3QgZGlyZWN0b3J5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgQ29udHJvbCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwjb25SZW5kZXIoKSI+b25SZW5kZXIoKTwvYT4gDQoJCXJlbmRlciBldmVudCBoYW5kbGVyLiBUaGlzIG1ldGhvZCBpcyB1c2VmdWwgZm9yIFBhbmVsIGNvbnRyb2xzIHBvcHVsYXRpbmcgdGFibGVzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgQ29udHJvbCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwjb25EZXN0cm95KCkiPm9uRGVzdHJveSgpPC9hPiANCgkJZGVzdHJveSBldmVudCBoYW5kbGVyLiBUaGlzIG1ldGhvZCBpcyB1c2VmdWwgZm9yIGNvbnRyb2xzIHRvIGZyZWUgcmVzb3VyY2VzLCB3aGVuIHRoZSBjb250cm9scw0KCQlhcmUgY29udGFpbmVkIGluIHN0YXRlZnVsIHBhZ2VzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvRXh0ZXJuYWxMaW5rLmh0bWwiPkV4dGVybmFsTGluazwvYT4gY29udHJvbC4gDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIEFic3RyYWN0Q29udHJvbCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0Q29udHJvbC5odG1sI2dldFBhZ2UoKSI+Z2V0UGFnZSgpPC9hPiBtZXRob2QuIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBDb250ZXh0IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNnZXRSZXF1ZXN0UGFyYW1ldGVyVmFsdWVzKCkiPmdldFJlcXVlc3RQYXJhbWV0ZXJWYWx1ZXMoKTwvYT4gbWV0aG9kLiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgQ29udGV4dCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwjaXNHZXQoKSI+aXNHZXQoKTwvYT4gbWV0aG9kLiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgRmllbGQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI2hlbHAiPmhlbHA8L2E+IHByb3BlcnR5IA0KICAgICAgCXRvIHJlbmRlciBoZWxwIHRleHQgdG8gdGhlIHJpZ2h0IGhhbmQgc2lkZSBvZiBmaWVsZHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIE1lbnUgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCNpbWFnZVNyYyI+aW1hZ2VTcmM8L2E+IHByb3BlcnR5IA0KICAgICAgCXRvIHN1cHBvcnQgZm9yIHJlbmRlcmluZyBpbWcgaWNvbnMgaW4gbWVudXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZW5hbWVkIENvbnRleHQgbWV0aG9kIDx0dD5nZXRSZXF1ZXN0UGFyYW1ldGVyczwvdHQ+IHRvDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNnZXRSZXF1ZXN0UGFyYW1ldGVyTWFwKCkiPmdldFJlcXVlc3RQYXJhbWV0ZXJNYXA8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlVcGRhdGUgbG9jYWxpemF0aW9uIGNsaWNrLWNvbnRyb2xfcHRfQlIucHJvcGVydGllcyBwcm92aWRlZCBieSBSaWNhcmRvIExlY2hldGENCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIyMSI+MjIxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIFNlbGVjdCwgQ2hlY2tMaXN0IGFuZCBQaWNrTGlzdCBjb250cm9scyB0byB1c2Ugc3RhbmRhcmQNCiAgICAgICAgPHR0PmdldFNlbGVjdGVkVmFsdWVzKCk8L3R0PiBtZXRob2QuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBDaHJpc3RvcGhlIEZPSVJFVA0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjIxIj4yMjY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJUmVtb3ZlZCBQYWdlIGFuZCBDb250cm9sIDx0dD5zZXRDb250ZXh0KCk8L3R0PiBtZXRob2RzLiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJUmVtb3ZlZCBGaWxlRmllbGQgPHR0PmZpbGVVcGxvYWQ8L3R0PiBwcm9wZXJ0eS4gDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBQYWdlIGNvbnRyb2wgYXV0b2JpbmRpbmcgYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgQ2hyaXN0b3BoZSBGT0lSRVQNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOTUiPjE5NTwvYT4sIDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOTUiPjIxMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ2xpY2tBcHAgbm90IHBpY2tpbmcgdXAgbmV3IFBhZ2UgY2xhc3NlcyBkeW5hbWljYWxseS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjIyIj4yMjI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgRm9ybSBpc0Zvcm1TdWJtaXNzaW9uKCkgbWV0aG9kIGZhaWxzIHdoZW4gY2FsbGVkIHR3aWNlIHdpdGggbXVsdGktcGFydCByZXF1ZXN0IGJ1Zw0KICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMjQiPjIyNDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBtYWNyby52bSBpcyBvbmx5IGF2YWlsYWJsZSBpZiB3YXIgaXMgdW5wYWNrZWQgYnVnLiBUaGlzIGlzc3VlIHdhcw0KICAgICAgCXJhaXNlZCBieSBBbmRydXMgQWRhbWNoaWsgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCiAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjMwIj4yMzA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIE9HTkwgRG91YmxlIHRvIEJpZ0RlY2ltYWwgdHlwZSBjb252ZXJzaW9uIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkDQoJCWJ5IEJlbiBXYXJuZXIgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vamlyYS5vcGVuc3ltcGhvbnkuY29tL2Jyb3dzZS9PR05MLTEyMiI+T0dOTC0xMjI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQ2F5ZW5uZSBsaWJyYXJ5IHRvIHZlcnNpb24gMi4wLjMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjMuMSAtIDExIEp1bmUgMjAwNzwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL0NheWVubmVGb3JtLmh0bWwiPkNheWVubmVGb3JtPC9hPiANCiAgICAgICAgdG8gaGFuZGxlIG5vbiBpbnRlZ2VyIHByaW1hcnkga2V5IHZhbHVlcy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFRvcmUgSGFsc2V0DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjExIj4yMTE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFJhZGlvR3JvdXAgaXMgc3RpbGwgYWN0aXZlIHdoZW4gc2V0IGl0IHRvIGRpc2FibGVkIGJ1Zy4gDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBDaHJpc3RvcGhlIEZPSVJFVA0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjE4Ij4yMTg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEZvcm0gZmlsZSB1cGxvYWQgY2hhcmFjdGVyIGVuY29kaW5nIE5QRS4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIFJvc2Vuc3RhcmsNCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIyMCI+MjIwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENvbW1vbnMgRmlsZVVwbG9hZCBsaWJyYXJ5IHRvIHZlcnNpb24gMS4yLiBGaXhlcyBidWcgd2hlcmUgZmlsZSANCiAgICAgICAgbmFtZXMgYXJlIGJlaW5nIGNvbnZlcnRlZCBpbnRvIGxvd2VyY2FzZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQ29tbW9ucyBJTyBsaWJyYXJ5IHRvIHZlcnNpb24gMS4zLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBDYXllbm5lIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjIuMy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgU3ByaW5nIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjIuOS4NCiAgICAgIDwvbGk+DQogICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMS4zIC0gNSBKdW5lIDIwMDc8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXBvcnRhbnQgQ2hhbmdlIA0KCQl0aGUgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDJzMDIuaHRtbCNhY3Rpdml0eS1kaWFncmFtIj5QYWdlczwvYT4gZXZlbnQgZXhlY3V0aW9uIG9yZGVyDQoJCWhhcyBjaGFuZ2VkIHdpdGggdGhlIDx0dD5vblNlY3VyaXR5Q2hlY2soKTwvdHQ+IG1ldGhvZCBub3cgaW52b2tlZCBiZWZvcmUgDQoJCXRoZSA8dHQ+b25Jbml0KCk8L3R0PiBtZXRob2QuIFRoZSBiZW5lZml0IG9mIHRoaXMgaXMgdGhhdCB0aGUgPHR0Pm9uSW5pdCgpPC90dD4gDQoJCWlzIG9ubHkgaW52b2tlZCBpZiB0aGUgcmVxdWVzdCBoYXMgcGFzc2VkIHRoZSA8dHQ+b25TZWN1cml0eUNoZWNrKCk8L3R0Pi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgDQogICAgICAJPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL1BpY2tMaXN0Lmh0bWwiPlBpY2tMaXN0PC9hPiBjb250cm9sLg0KICAgICAgCVRoaXMgY29udHJvbCB3YXMgY3JlYXRlZCBieSBOYW9raSBUYWtlem9lIA0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTk0Ij4xOTQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9UcmVlLmh0bWwiPlRyZWU8L2E+IGNvbnRyb2wgY2xpZW50IHNpZGUgamF2YXNjcmlwdCBmdW5jdGlvbmFsaXR5LiANCgkJVGhpcyB3YXMgcHJvdmlkZWQgYnkgQm9iIFNjaGVsbGluayANCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xODYiPjE4NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2FwcGxpY2F0aW9uLWF1dG9iaW5kaW5nIj5hdXRvYmluZGluZzwvYT4gY29uZmlndXJhdGlvbiBvcHRpb24uDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFobWVkIE1vaG9tYmUgDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOTkiPjE5OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgPHR0PnRhYmluZGV4PC90dD4gc3VwcG9ydCB0byANCgkJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BYnN0cmFjdExpbmsuaHRtbCI+QWJzdHJhY3RMaW5rPC9hPiBhbmQgDQoJCTxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCI+RmllbGQ8L2E+IGNvbnRyb2xzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgRm9ybSAgDQoJCTxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2RlZmF1bHRGaWVsZFNpemUiPmRlZmF1bHRGaWVsZFNpemU8L2E+IHByb3BlcnR5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wcm92ZWQgPHR0PnRyYWNlPC90dD4gbGV2ZWwgbG9nZ2luZyB0byBkZXRhaWwgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sIj5QYWdlPC9hPiBldmVudCBleGVjdXRpb24gb3JkZXIuIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wcm92ZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0VtYWlsRmllbGQuaHRtbCI+RW1haWxGaWVsZDwvYT4gdmFsaWRhdGlvbi4gDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlDaGFuZ2VkIGRlZmF1bHQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwiPkZvcm08L2E+IGVycm9yUG9zdGlvbiBmcm9tIDx0dD4ibWlkZGxlIjwvdHQ+IHRvIDx0dD4idG9wIjwvdHQ+LiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9DYXllbm5lRm9ybS5odG1sIj5DYXllbm5lRm9ybTwvYT4gDQoJCWhhbmRsaW5nIG9mIG5ldyBvYmplY3RzIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFuZHJ1cyBBZGFtY2hpayANCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MyI+NzM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmlsZUZpZWxkLmh0bWwiPkZpbGVGaWVsZDwvYT4gDQoJCWNvbmZpZ3VyYXRpb25zIG5vdCBiZSBhcHBsaWVkIGluIGNlcnRhaW4gc2NlbmFyaW9zLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFNhZGFub3JpIEl0byANCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNzkiPjE3OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgUGFnZSB3aXRoIHR3byA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1RhYmxlLmh0bWwiPlRhYmxlPC9hPg0KCSAgICBjb250cm9scyBwcm9kdWNlcyB1bm5lZWRlZCBjc3Mgc3R5bGUgdGV4dCBidWcuIA0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSi5GLiBaYXJhbWEgIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE5NyI+MTk3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTGlua0RlY29yYXRvci5odG1sIj5MaW5rRGVjb3JhdG9yPC9hPiB0YWJsZSBzb3J0aW5nIHN1cHBvcnQuIA0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgTG91aXMgTWFydGluIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rIA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIwNyI+MjA3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1RhYmxlLmh0bWwiPlRhYmxlPC9hPiBjb2x1bW4gc29ydGluZyBidWcuIA0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgTG91aXMgTWFydGluIGFuZCBmaXhlZCBieSBOYW9raSBUYWtlem9lICANCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMDgiPjIwODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMS4yIC0gMjJuZCBNYXJjaCAyMDA3PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbTowLjVlbTsiPiBOZXcgZGV2ZWxvcGVyDQogICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9zYWJvYi8iPkJvYiBTY2hlbGxpbms8L2E+DQogICAgam9pbnMgdGhlIENsaWNrIHByb2plY3QuPC9kaXY+ICANCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgY29udHJvbHMgDQogICAgICAJPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL1RyZWUuaHRtbCI+VHJlZTwvYT4gYW5kDQogICAgICAJPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL0NoZWNrYm94VHJlZS5odG1sIj5DaGVja2JveFRyZWU8L2E+Lg0KICAgICAgCVRoZXNlIGNvbnRyb2xzIHdlcmUgY3JlYXRlZCBieSBCb2IgU2NoZWxsaW5rDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTYwIj4xNjA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgY29udHJvbHMgSlNCYXJDaGFydCwgSlNMaW5lQ2hhcnQgYW5kIEpTUGllQ2hhcnQuDQogICAgICAJVGhlc2UgY29udHJvbHMgd2VyZSBjcmVhdGVkIGJ5IEFobWVkIE1vaG9tYmUuDQogICAgICAgIDxzcGFuIGNsYXNzPSJyZWQiPlVwZGF0ZTo8L3NwYW4+IHRoZXNlIGNvbnRyb2xzIHdlcmUgbW92ZWQgdG8gdGhlDQogICAgICAgIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vcC9jbGljay1jaGFydHMvIj5DbGljayBDaGFydHM8L2E+DQogICAgICAgIHByb2plY3QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIEZpZWxkIGNvbnZlbmllbmNlIG1ldGhvZHMgZm9yIHNldHRpbmcgc3R5bGUsIHRleHQtYWxpZ24gYW5kIHdpZHRoIEhUTUwgYXR0cmlidXRlcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG11bHRpcGxlIEFjdGlvbkJ1dHRvbiBwYXJhbWV0ZXJzLCBzZWUgDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWN0aW9uQnV0dG9uLmh0bWwjc2V0UGFyYW1ldGVyKGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5TdHJpbmcpIj5zZXRQYXJhbWV0ZXIoKTwvYT4NCiAgICAgICAgZm9yIGRldGFpbHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBBYnN0cmFjdExpbmsNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BYnN0cmFjdExpbmsuaHRtbCNpbWFnZVNyYyI+aW1hZ2VTcmM8L2E+DQogICAgICAgIHByb3BlcnR5IGZvciByZW5kZXJpbmcgaW1nIGljb25zIGluc2lkZSBsaW5rcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgY2xhc3MgaGllcmFyY2h5IG1lc3NhZ2VzIGluaGVyaXRhbmNlIHRvIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvTWVzc2FnZXNNYXAuaHRtbCI+TWVzc2FnZXNNYXA8L2E+Lg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBbmRydXMgQWRhbWNoaWsNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03NCI+NzQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEFjdGlvbkJ1dHRvbiBzdXBwb3J0IHRvIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9MaW5rRGVjb3JhdG9yLmh0bWwiPkxpbmtEZWNvcmF0b3I8L2E+Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUmljYXJkbyBMZWNoZXRhDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTM1Ij4xMzU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG9yZGVyaW5nIHN1cHBvcnQgdG8gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL1Byb3BlcnR5U2VsZWN0Lmh0bWwiPlByb3BlcnR5U2VsZWN0PC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTU0Ij4xNTQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEZpZWxkU2V0IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGRTZXQuaHRtbCNjb2x1bW5zIj5jb2x1bW5zPC9hPiBwcm9wZXJ0eS4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgTG9yZW56byBPcnNlbGxpDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTU4Ij4xNTg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG9wdGlvbmFsIHByb3BlcnR5IHRvIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9RdWVyeVNlbGVjdC5odG1sI29wdGlvbmFsIj5RdWVyeVNlbGVjdDwvYT4gYW5kDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9Qcm9wZXJ0eVNlbGVjdC5odG1sI29wdGlvbmFsIj5Qcm9wZXJ0eVNlbGVjdDwvYT4gY29udHJvbHMuDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IExvcmVuem8gT3JzZWxsaQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE1NiI+MTU2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIHN1cHBvcnQgZm9yIE5hbWVkUXVlcnkgb2JqZWN0cyBpbg0KICAgICAgCTxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9Qcm9wZXJ0eVNlbGVjdC5odG1sI25hbWVkUXVlcnkiPlByb3BlcnR5U2VsZWN0PC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTY2Ij4xNjY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgSXRhbGlhbiBhbmQgRnJlbmNoIENvbG9yUGlja2VyIGFuZCBUZWxlcGhvbmVGaWVsZCBwcm9wZXJ0aWVzIHByb3ZpZGVkIGJ5IExvcmVuem8gT3JzZWxsaQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE3MSI+MTcxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIENoaW5lc2UgbG9jYWxpemF0aW9uIHByb3BlcnRpZXMgcHJvdmlkZWQgYnkgTGFycnkgTGkNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNzciPjE3NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwiPkNsaWNrVXRpbHM8L2E+IA0KICAgICAgICBjb29raWUgaGFuZGxpbmcgbWV0aG9kcywgYW5kIGNvbnZlbmllbmNlIG1ldGhvZHMgaW4gdGhlIENvbnRleHQgY2xhc3MuDQogICAgICAJVGhlc2UgbWV0aG9kcyB3ZXJlIGRlcml2ZWQgZnJvbSB0aGUgQXRsYXNzaWFuIA0KICAgICAgCTxhIHRhcmdldD0iYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL29wZW5zb3VyY2UuYXRsYXNzaWFuLmNvbS9zZXJhcGgvYXBpZG9jcy9jb20vYXRsYXNzaWFuL3NlcmFwaC91dGlsL0Nvb2tpZVV0aWxzLmh0bWwiPkNvb2tpZVV0aWxzPC9hPg0KICAgICAgCWNsYXNzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCI+TWVudTwvYT4gcHJvcGVydGllcw0KICAgICAgICBleHRlcm5hbCBhbmQgdGFyZ2V0LCBhbmQgY2hhbmdlZCA8dHQ+dG9TdHJpbmcoKTwvdHQ+IG1ldGhvZCB0byByZW5kZXIgYW4gSFRNTCBhbmNob3IgdGFnLiANCiAgICAgICAgVGhlc2UgY2hhbmdlcyBzaW1wbGlmeSBtZW51IFZlbG9jaXR5IG1hY3Jvcy4NCiAgICAgICAgUGxlYXNlIG5vdGUgdGhlIDx0dD5pc1VzZXJJblJvbGVzKCk8L3R0PiBtZXRob2Qgbm93IHJldHVybnMgZmFsc2UgaWYgdGhlcmUgYXJlIG5vIHJvbGVzDQogICAgICAgIGRlZmluZWQgZm9yIHRoZSBtZW51IGl0ZW0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9EYXRhQ29udGV4dEZpbHRlci5odG1sIj5EYXRhQ29udGV4dEZpbHRlcjwvYT4gc3VwcG9ydCBmb3IgDQogICAgICAJc2Vzc2lvbiBvciByZXF1ZXN0IHNjb3BlIERhdGFDb250ZXh0IG9iamVjdHMsIGFuZCBjb250cm9sbGluZyB0aGUgdXNlIG9mIHRoZSBDYXllbm5lIHNoYXJlZCBjYWNoZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgQ2F5ZW5uZSBEQU8vU2VydmljZSBiYXNlIGNsYXNzIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9DYXllbm5lVGVtcGxhdGUuaHRtbCI+Q2F5ZW5uZVRlbXBsYXRlPC9hPg0KICAgICAgCXRvIENsaWNrIEV4dHJhcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgYXV0b21hcHBpbmcgc3VwcG9ydCBmb3IgL2NsaWNrL2Vycm9yLmh0bSBwYWdlcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIENsaWNrU2VydmxldCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNjcmVhdGVDbGlja0xvZ2dlcigpIj5jcmVhdGVDbGlja0xvZ2dlcigpPC9hPiANCiAgICAgICAgbWV0aG9kIHRvIHN1cHBvcnQgY3VzdG9taXppbmcgQ2xpY2sgcnVudGltZSBlbmdpbmUgbG9nZ2luZy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEJvYiBTY2hlbGxpbmsuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBDb2x1bW4gPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Db2x1bW4uaHRtbCN0aXRsZVByb3BlcnR5Ij50aXRsZVByb3BlcnR5PC9hPiANCiAgICAgICAgYXR0cmlidXRlIHRvIHN1cHBvcnQgcmVuZGVyaW5nICZsdDt0ZCZndDsgdGl0bGUgYXR0cmlidXRlcy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZyaXplbGxlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgPGEgaHJlZj0iY2xpY2staWRlLmh0bWwiPkNsaWNrSURFPC9hPiBkb2N1bWVudGF0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgUGFnZSA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMwMy5odG1sI3JlcXVlc3QtcGFyYW0tYXV0by1iaW5kaW5nIj5SZXF1ZXN0IFBhcmFtIEF1dG8gQmluZGluZzwvYT4gZG9jdW1lbnRhdGlvbiB0b3BpYy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEJlc3QgUHJhY3RpY2VzIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA1czAyLmh0bWwjcGFja2FnZXMtY2xhc3NlcyI+UGFja2FnZXMgYW5kIENsYXNzZXM8L2E+IGRvY3VtZW50YXRpb24gdG9waWMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCB1c2FiaWxpdHkgb2YgRmllbGQgbGFiZWxzLCBwcm92aWRpbmcgZmllbGQgbGFiZWwgZm9jdXMgc3VwcG9ydC4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2UgYW5kIGZpeGVkIGJ5IFNhZGFub3JpIEl0bw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE1OSI+MTU5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUltcHJvdmVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvSW1hZ2VTdWJtaXQuaHRtbCNzcmMiPkltYWdlU3VibWl0PC9hPiANCiAgICAgIAlzcmMgcmVuZGVyaW5nIGJ5IHByZWZpeGluZyBjb250ZXh0IHBhdGgNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNjUiPjE2NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NvbHVtbi5odG1sI2dldEhlYWRlclRpdGxlKCkiPkNvbHVtbjwvYT4gDQogICAgICAJaTE4biBzdXBwb3J0IGZvciBoZWFkZXIgdGl0bGVzLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUmljYXJkbyBMZWNoZXRhDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTc2Ij4xNzY8L2E+XS4NCiAgICAgIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCBGb3JtIA0KICAgICAgCTxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2VuZFRhZygpIj5lbmRUYWcoKTwvYT4gDQogICAgICAJcmVuZGVyaW5nIHRvIGluY2x1ZGUgSmF2YVNjcmlwdCBmb2N1cyBhbmQgdmFsaWRhdGlvbiBjb2RlLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJSW1wcm92ZWQgVGFibGUgY29sdW1uIHNvcnRpbmcuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCBlcnJvciByZXBvcnRpbmcgZm9yIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbnMuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCBBYnN0cmFjdExpbmsgcmVuZGVyaW5nIG9mIGRpc2FibGVkIGxpbmtzLCBub3cgcmVuZGVyIGFzIGEgc3BhbiBlbGVtZW50Lg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJUmVmYWN0b3JlZCBEb3VibGVGaWVsZCwgSW50ZWdlckZpZWxkIGFuZCBMb25nRmllbGQgdG8gc3ViY2xhc3MgDQogICAgICAJPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL051bWJlckZpZWxkLmh0bWwiPk51bWJlckZpZWxkPC9hPi4gDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFobWVkIE1vaG9tYmUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMjAiPjEyMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlSZW1vdmVkIHN1cHBvcnQgZm9yIGxvZ2dpbmcgdG8gU2VydmxldCBsb2cuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIEFjdGlvbkxpbmsgc2V0VmFsdWVPYmplY3QoKSBub3Qgc2V0dGluZyBudWxsIHZhbHVlcy4gDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTUwIj4xNTA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgbXVsdGlwbGUgRm9ybSBzdXBwb3J0IGluIHBhZ2VzIHdpdGggYW4gZmlsZSB1cGxvYWQgZm9ybQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE1MiI+MTUyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIHJlYWRvbmx5IHN1cHBvcnQgaW4gPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9DaGVja2JveC5odG1sIj5DaGVja2JveDwvYT4sDQogICAgICAJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9SYWRpby5odG1sIj5SYWRpbzwvYT4gYW5kDQogICAgICAJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9TZWxlY3QuaHRtbCI+U2VsZWN0PC9hPiBjb250cm9scy4gDQogICAgICAJVGhlc2UgaXNzdWVzIHdlcmUgcmFpc2VkIGJ5IExvcmVuem8gT3JzZWxsaSBhbmQgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNTUiPjE1NTwvYT4sDQogICAgICAgICA8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTY0Ij4xNjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgZXJyb3IgcG9zaXRpb24gc3VwcG9ydCBpbiA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvVGFiYmVkRm9ybS5odG1sIj5UYWJiZWRGb3JtPC9hPiBjb250cm9sLiANCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgTG9yZW56byBPcnNlbGxpDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTU3Ij4xNTc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgZGlmZmVyZW5jZXMgb2YgSmF2YS9KYXZhU2NyaXB0IGVycm9yIG1lc3NhZ2UuIA0KICAgICAgCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgU2FkYW5vcmkgSXRvDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTYxIj4xNjE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgZmlyc3QgZGF5IG9mIHdlZWsgYnVnIGluIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9EYXRlRmllbGQuaHRtbCI+RGF0ZUZpZWxkPC9hPiBjb250cm9sLiANCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFNhZGFub3JpIEl0bw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE3MCI+MTcwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIEZvcm0NCiAgICAgIAk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNjb3B5VG8oamF2YS5sYW5nLk9iamVjdCkiPmNvcHlUbzwvYT4gDQogICAgICAJTWFwIHN1cHBvcnQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBMb3VpcyBNYXJ0aW4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNzIiPjE3MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBGaWxlRmllbGQgSmF2YVNjcmlwdCB2YWxpZGF0aW9uIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCANCiAgICAgIAlieSBTYWRhbm9yaSBJdG8NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNzgiPjE3ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBQcm9wZXJ0eVNlbGVjdCBhcHBsaWVzIG9yZGVyaW5nIHR3aWNlIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IExhcnJ5IEJ1bnRvbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE4MyI+MTgzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIHdyb25nIGZvcm0gSFRNTCBnZW5lcmF0aW9uLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUmljYXJkbyBMZWNoZXRhDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTg5Ij4xODk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZSBWZWxvY2l0eSBsaWJyYXJ5IHRvIHZlcnNpb24gMS41LWJldGEyLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBDYXllbm5lIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjIuMi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIA0KICA8ZHQ+VmVyc2lvbiAxLjEgLSAyMiBOb3ZlbWJlciAyMDA2PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbTowLjVlbTsiPiBOZXcgZGV2ZWxvcGVyDQogICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9zaGFiZXJtYW4vIj5TdGVwaGVuIEhhYmVybWFuPC9hPg0KICAgIGpvaW5zIHRoZSBDbGljayBwcm9qZWN0LjwvZGl2PiAgDQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIEZvcm0gZmllbGQgd2lkdGggZ3JpZCBsYXlvdXQgcmVuZGVyaW5nIG9wdGlvbi4gU2VlIHRoZSBGb3JtIA0KICAgICAgCTxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2FkZChvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuRmllbGQsIGludCkiPmFkZChmaWVsZCwgd2lkdGgpPC9hPiBtZXRob2QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIFRhYmxlIENvbHVtbiBzb3J0aW5nIHN1cHBvcnQuIFNlZSB0aGUgQ29sdW1uIA0KICAgICAgCTxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQ29sdW1uLmh0bWwjc29ydGFibGUiPnNvcnRhYmxlPC9hPiBwcm9wZXJ0eS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgQ29sdW1uIGNvbnZlbmllbmNlIG1ldGhvZHMgZm9yIHNldHRpbmcgd2lkdGgsIHRleHQtYWxpZ24sIA0KICAgICAgCXZlcnRpY2FsLWFsaWduIGF0dHJpYnV0ZXMsIGFuZCBzZXR0aW5nIGRhdGEgYW5kIGhlYWRlciBzdHlsZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIGF1dG8gYmluZGluZyBvZiByZXF1ZXN0IHZhbHVlcyB0byBwdWJsaWMgUGFnZSBmaWVsZHMuIFNlZSB0aGUgQ2xpY2tTZXJ2bGV0IG1ldGhvZCANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ2xpY2tTZXJ2bGV0Lmh0bWwjcHJvY2Vzc1BhZ2VSZXF1ZXN0UGFyYW1zKG9yZy5hcGFjaGUuY2xpY2suUGFnZSwgamF2YXguc2VydmxldC5odHRwLkh0dHBTZXJ2bGV0UmVxdWVzdCkiPnByb2Nlc3NQYWdlUmVxdWVzdFBhcmFtcygpPC9hPg0KICAgICAgICBmb3IgZGV0YWlscy4gVGhpcyBhZGRpdGlvbiB3YXMgcmFpc2VkIGJ5IFN0ZXBoZW4gSGFiZXJtYW4uIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgRm9ybQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNjbGVhclZhbHVlcygpIj5jbGVhclZhbHVlcygpPC9hPiANCiAgICAgICAgbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgQ2xpY2tVdGlscyANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwjZ2V0TWltZVR5cGUoamF2YS5sYW5nLlN0cmluZykiPmdldE1pbWVUeXBlKCk8L2E+IA0KICAgICAgICBtZXRob2QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBvdmVycmlkaW5nIENsaWNrIEFwcGxpY2F0aW9uIG1vZGUgYnkgZGVmaW5pbmcgYSBTeXN0ZW0gcHJvcGVydHkgPHR0PmNsaWNrLm1vZGU8L3R0Pi4gDQogICAgICAgIEZvciBleGFtcGxlOiA8dHQ+LURjbGljay5tb2RlPXRyYWNlPC90dD4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJSW1wcm92ZWQgVGFibGUgcGFnaW5nIGFjcm9zcyB2ZXJ5IGxhcmdlIGxpc3RzLg0KICAgICAgPC9saT4gICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUltcHJvdmVkIFRhYmxlIHJlbmRlcmluZyBwZXJmb3JtYW5jZS4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMzYiPjEzNjwvYT5dLg0KICAgICAgPC9saT4gICAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCBPR05MIGZvcm0gYmluZGluZyBwZXJmb3JtYW5jZS4NCiAgICAgIDwvbGk+ICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBDbGljayBjb25maWd1cmF0aW9uIGRlZmF1bHRzOg0KICAgICAgICA8dWwgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+cGFnZSBhdXRvbWFwcGluZyBpcyBlbmFibGVkIGJ5IGRlZmF1bHQ8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5nbG9iYWwgbm8gY2FjaGUgaGVhZGVycyBhcmUgdXNlZCBpZiBubyBoZWFkZXJzIGRlZmluZWQ8L2xpPg0KICAgICAgICA8L3VsPg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlVcGRhdGVkIENsaWNrU2VydmxldCB0byB1c2UgcmVzcG9uc2UgV3JpdGVyIHRvIHN1cHBvcnQgdGhlIA0KICAgICAgCTxhIGhyZWY9Imh0dHA6Ly9tZXNzYWRtaW4uc291cmNlZm9yZ2UubmV0LyI+TWVzc0FkbWluPC9hPiBzZXNzaW9uIG1vbml0b3JpbmcgdG9vbC4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IFN2ZW4gSGVyc2NoZWwgYW5kIGEgcGF0Y2ggd2FzIHByb3ZpZGVkIGJ5DQogICAgICAJQm9iIFNjaGVsbGluaw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE0NiI+MTQ2PC9hPl0uDQogICAgICA8L2xpPiAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBOUEUgaW4gUHJvcGVydHlTZWxlY3Qgd2hlbiBsYWJlbCBpcyBudWxsLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMzIiPjEzMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBPZ25sRXhjZXB0aW9uIGluIENvbHVtbiB3aGVuIGV2YWx1YXRpbmcgbnVsbCBwcm9wZXJ0eSBwYXRocy4gDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTMzIj4xMzM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgT2dubCBOdWxsIHByb3BlcnR5IGV2YWx1YXRpb24gYnVnIHdoZW4gaGFuZGxpbmcgRGF0ZSBwcm9wZXJ0aWVzLiANCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMzciPjEzNzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBKU1AgcGFnZSBhdXRvbWFwcGluZyBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNDIiPjE0MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBIaWJlcm5hdGVGb3JtIG5vdCB3b3JraW5nIGZvciBDR0xpYiBwcm94aWVzLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIA0KICAgICAgCWFuZCBmaXhlZCBieSBDYXJvbGluZSBCcmlmZmEgDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTQ0Ij4xNDQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgQ2F5ZW5uZUZvcm0gYnVnIHdoZXJlIEZPSUQgd2FzIG5vdCBiZWluZyB1cGRhdGVkIGZvciByZWNlbnRseSBjb21taXR0ZWQgRGF0YU9iamVjdC4gDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTQ1Ij4xNDU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGRlcGVuZGVuY3kgb24gRG91Z2ggTGVhJ3MgQ29uY3VycmVudCBVdGlsaXRpZXMgbGlicmFyeSB2ZXJzaW9uIDEuMy40Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlIFZlbG9jaXR5IDEuNS1kZXYgbGlicmFyeSB0byBTVk4gcmV2aXNpb24gNDY3MTc5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBPR05MIGxpYnJhcnkgdG8gdmVyc2lvbiAyLjYuOS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuIENsaWNrIFF1aWNrc3RhcnQgaGFzIGFsc28gYmVlbiBhZGRlZCANCiAgICAgICAgYXMgYW4gZXhhbXBsZSBhcHBsaWNhdGlvbi4NCiAgICAgIDwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMS4wIC0gM3JkIE9jdG9iZXIgMjAwNjwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9ImNsaWNrLWNoZWF0LXNoZWV0LnBkZiI+Q2hlYXQgU2hlZXQ8L2E+IGd1aWRlLg0KICAgICAgCVRoaXMgZmVhdHVyZSB3YXMgcmFpc2VkIGJ5IEFobWVkIE1vaG9tYmUgYW5kIFJpY2FyZG8gTGVjaGV0YS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgQ29sdW1uIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQ29sdW1uLmh0bWwjbWF4TGVuZ3RoIj5tYXhMZW5ndGg8L2E+IHByb3BlcnR5DQogICAgICAJdG8gbGltaXQgdGhlIG51bWJlciBjaGFyYWN0ZXJzIGRpc3BsYXllZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgTlBFIGluIFRhYmxlIEFjdGlvbkxpbmsgcGFnaW5hdGlvbi4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEyNCI+MTI0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIGN1c3RvbSBFcnJvclBhZ2Ugbm90IHJlc29sdmluZy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEdsZW4gU3RhbXBvdWx0emlzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTI2Ij4xMjY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgTnVtYmVyRm9ybWF0RXhjZXB0aW9uIGluIExpbmtEZWNvcmF0b3INCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEyNyI+MTI3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIE51bWJlckZvcm1hdEV4Y2VwdGlvbiB3aGVuIHVzaW5nIEZvcm0ub25TdWJtaXRDaGVjaygpIHdpdGggYSBGaWxlRmllbGQuDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBTYXRvc2hpIFRha2F0YQ0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTI3Ij4xMjg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgQ2F5ZW5uZUZvcm0gYnVnIHdpdGggcmVxdWlyZWQgcHJvcGVydHkgc2V0IG9uIENoZWNrYm94Lg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEyOSI+MTI5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIFByb3BlcnR5U2VsZWN0IGJ1ZyB3aGVyZSBmaXJzdCBpdGVtIGRpc3BsYXlzIHR3aWNlIHVuZGVyIGNlcnRhaW4gY29uZGl0aW9ucy4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMzAiPjEzMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlVcGRhdGVkIGFuZCB2ZXJpZmllZCBDbGljayBGcmFtZXdvcmsgYW5kIEV4dHJhcyBjb2RlYmFzZSBhZ2FpbnN0IDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vZmluZGJ1Z3Muc291cmNlZm9yZ2UubmV0L2luZGV4Lmh0bWwiPkZpbmRCdWdzPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQ2F5ZW5uZSBsaWJyYXJ5IHRvIHZlcnNpb24gMS4yLjEuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjAgUkMyIC0gNnRoIFNlcHRlbWJlciAyMDA2PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9GbGFzaEF0dHJpYnV0ZS5odG1sIj5GbGFzaEF0dHJpYnV0ZTwvYT4NCiAgICAgICAgY2xhc3MgcHJvdmlkaW5nIGZsYXNoIHNjb3BlIHNlc3Npb24gYXR0cmlidXRlcy4gT25jZSBhIGZsYXNoIGF0dHJpYnV0ZSANCiAgICAgICAgaGFzIGJlZW4gYWNjZXNzZWQgZnJvbSB0aGUgc2Vzc2lvbiBpdCBpcyByZW1vdmVkLiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9MaW5rRGVjb3JhdG9yLmh0bWwiPkxpbmtEZWNvcmF0b3I8L2E+DQogICAgICAgIGNsYXNzIGZvciByZW5kZXJpbmcgYWN0aW9uIGxpbmtzIGluIGNvbHVtbiB0YWJsZXMuIFRoaXMgY2xhc3Mgd2FzIGluc3BpcmVkIA0KICAgICAgICBieSBSaWNoYXJkbyBMZWNoZXRhJ3MgPHR0PlZpZXdEZWNvcmF0b3I8L3R0PiBwYXR0ZXJuLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgcGFnaW5nIHN1cHBvcnQgdG8gDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9Gb3JtVGFibGUuaHRtbCI+Rm9ybVRhYmxlPC9hPiANCiAgICAgICAgY29udHJvbC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sIj5Gb3JtPC9hPg0KICAgICAgICBzdGFydFRhZygpIGFuZCBlbmRUYWcoKSBtZXRob2RzIHRvIHN1cHBvcnQgbGF5aW5nIG91dCBmb3JtcyBtYW51YWxseS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEZvcm0NCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjY2xlYXJFcnJvcnMoKSI+Y2xlYXJFcnJvcnMoKTwvYT4gDQogICAgICAgIG1ldGhvZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIFBhZ2UgdGVtcGxhdGluZyBzdXBwb3J0IGZvciBKU1AgcGFnZXMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlIGJ5IEh1eSBEby4gDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBUYWl3YW4gcHJvcGVydGllcyBmaWxlIHByb3ZpZGVkIGJ5IEh1YW5nLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IENsaWNrIExvZ28gcHJvdmlkZWQgYnkgQWhtZWQgTW9ob21iZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIEZvcm0gY2xpZW50IHNpZGUgSmF2YVNjcmlwdCB2YWxpZGF0aW9uIHByb3ZpZGVkIGJ5IE5hb2tpIFRha2V6b2UNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMTUiPjExNTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlVcGRhdGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQ29sdW1uLmh0bWwiPkNvbHVtbjwvYT4NCiAgICAgICAgY2xhc3MgdG8gZXNjYXBlIEhUTUwgY2hhcmFjdGVycyBieSBkZWZhdWx0LiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgDQogICAgICAgIEdsZW4gU3RhbXBvdWx0emlzIA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTExOCI+MTE4PC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9IdG1sU3RyaW5nQnVmZmVyLmh0bWwiPkh0bWxTdHJpbmdCdWZmZXI8L2E+DQogICAgICAgIHRvIGltcHJvdmUgSFRNTCBjaGFyYWN0ZXIgZXNjYXBpbmcgcGVyZm9ybWFuY2UsIHJlbW92aW5nIEFwYWNoZSBDb21tb25zIExhbmcncyB1c2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9maXNoZXllMy5jZW5xdWEuY29tL2Jyb3dzZS9jbGljay8iPkZpc2hFeWU8L2E+IHByb2plY3QgdmlldyANCiAgICAgICAgcHJvdmlkZWQgYnkgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3d3dy5jZW5xdWEuY29tIj5DZW5xdWE8L2E+LiAgICAgIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBDYXllbm5lIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjIuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIEhpYmVybmF0ZSBsaWJyYXJ5IHRvIHZlcnNpb24gMy4xLjMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvZmlsdGVyL0NvbXByZXNzaW9uRmlsdGVyLmh0bWwiPkNvbXByZXNzaW9uRmlsdGVyPC9hPg0KICAgICAgICB0byBjb21wcmVzcyByZXNwb25zZSBieSBkZWZhdWx0IGFuZCB0byBhdXRvbWF0aWNhbGx5IHNldCBhbnkgY29uZmlndXJlZCBDbGljayBjaGFyc2V0LiANCiAgICAgICAgVGhlc2UgaXNzdWVzIHdlcmUgcmFpc2VkIGJ5IFJpY2FyZG8gTGVjaGV0YSBhbmQgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTExOSI+MTE5PC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBOUEUgaW4gRGF0ZUZpZWxkIHdoZW4gc2V0dGluZyB2YWx1ZSB0byBudWxsLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgR2VvZmYgSG9wc29uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTIxIj4xMjE8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjAgUkMxIC0gMzF0aCBKdWx5IDIwMDY8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvRm9ybVRhYmxlLmh0bWwiPkZvcm1UYWJsZTwvYT4NCiAgICAgICAgZGF0YSBncmlkIGNvbnRyb2wgYW5kIGFzc29jaWF0ZWQgDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9GaWVsZENvbHVtbi5odG1sIj5GaWVsZENvbHVtbjwvYT4NCiAgICAgICAgY2xhc3MuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUGFnZVN1Ym1pdC5odG1sIj5QYWdlU3VibWl0PC9hPg0KICAgICAgICBjb250cm9sIGZvciByZWRpcmVjdGluZyB0byB0YXJnZXQgcGFnZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIFBhZ2UNCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0Rm9yd2FyZChqYXZhLmxhbmcuQ2xhc3MpIj5zZXRGb3J3YXJkKENsYXNzKTwvYT4gbWV0aG9kLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgDQogICAgICAgPGEgaHJlZj0icXVpY2stc3RhcnQuaHRtbCI+UXVpY2sgU3RhcnQ8L2E+IHRvcGljIHRvIENsaWNrIGRvY3VtZW50YXRpb24uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTW9kaWZpZWQgRm9ybQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNpc0Zvcm1TdWJtaXNzaW9uKCkiPmlzRm9ybVN1Ym1pc3Npb24oKTwvYT4NCiAgICAgICAgbWV0aG9kIHRvIG9ubHkgcmV0dXJuIHRydWUgaWYgdGhlIHN1Ym1pc3Npb24gaXMgZnJvbSB0aGlzIGZvcm0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjIxIC0gMTl0aCBKdWx5IDIwMDY8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjAuNWVtOyI+IA0KICAgIEZpbmFsIG5ldyBmZWF0dXJlcyByZWxlYXNlIGZvciBDbGljayAxLjAuPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIFBhZ2UgDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI29uUmVuZGVyKCkiPm9uUmVuZGVyKCk8L2E+DQogICAgICAgbWV0aG9kLiBUaGlzIGFkZGl0aW9uIHdhcyByYWlzZWQgYnkgU3RlcGhlbiBIYWJlcm1hbg0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTA1Ij4xMDU8L2E+XS4NCiAgICAgIDwvbGk+ICAgICAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBdXRvIGFkZCBwdWJsaWMgUGFnZSBmaWVsZHMgdG8gdGhlIG1vZGVsLiANCiAgICAgICBTZWUgdGhlIENsaWNrU2VydmxldCBtZXRob2RzDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ2xpY2tTZXJ2bGV0Lmh0bWwjaW5pdFBhZ2UoamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLkNsYXNzLCBqYXZheC5zZXJ2bGV0Lmh0dHAuSHR0cFNlcnZsZXRSZXF1ZXN0KSI+aW5pdFBhZ2UoKTwvYT4NCiAgICAgICBhbmQgDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ2xpY2tTZXJ2bGV0Lmh0bWwjY3JlYXRlVmVsb2NpdHlDb250ZXh0KG9yZy5hcGFjaGUuY2xpY2suUGFnZSkiPmNyZWF0ZVZlbG9jaXR5Q29udGV4dCgpPC9hPg0KICAgICAgIGZvciBkZXRhaWxzLiBUaGlzIGFkZGl0aW9uIHdhcyByYWlzZWQgYnkgU3RlcGhlbiBIYWJlcm1hbg0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTA5Ij4xMDk8L2E+LA0KICAgICAgIDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMTIiPjExMjwvYT5dLg0KICAgICAgPC9saT4gICAgICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIFJlZmFjdG9yZWQgcGFuZWwgcGFja2FnZSB3aXRoIEJhc2ljUGFuZWwgcmVuYW1lZCANCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1BhbmVsLmh0bWwiPlBhbmVsPC9hPiBhbmQgbW92ZWQNCiAgICAgICBpbnRvIHRoZSBjb3JlIGNvbnRyb2wgcGFja2FnZSwgYW5kIHJlbW92aW5nIHRoZSBQYW5lbCBpbnRlcmZhY2UuDQogICAgICAgVGhlIA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvcGFuZWwvTGlzdFBhbmVsLmh0bWwiPkxpc3RQYW5lbDwvYT4NCiAgICAgICBhbmQgIA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvcGFuZWwvVGFiYmVkUGFuZWwuaHRtbCI+VGFiYmVkUGFuZWw8L2E+DQogICAgICAgY2xhc3NlcyBoYXZlIGJlZW4gcmV2aXNlZCB0byB0YWtlIGFkdmFudGFnZSBvZiB0aGUgbmV3IFBhbmVsIGNhcGFiaWxpdGllcy4NCiAgICAgICA8cC8+DQogICAgICAgUGFuZWxzIGFyZSBub3cgcmVuZGVyZWQgYXMgPHR0PiRwYW5lbDwvdHQ+IHJhdGhlciB0aGFuIDx0dD4jcGFyc2UoJHBhbmVsKTwvdHQ+IA0KICAgICAgIDxwLz4gICAgICAgDQogICAgICAgUGFuZWxzIGNhbiBub3cgZGVmaW5lIFZlbG9jaXR5IHRlbXBsYXRlcyBvbiB0aGUgY2xhc3NwYXRoIGFzIHdlbGwgYXMgdGhlIHdlYiBmaWxlIHN5c3RlbS4NCiAgICAgIDwvbGk+ICAgICAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCANCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1BhZ2VMaW5rLmh0bWwiPlBhZ2VMaW5rPC9hPg0KICAgICAgIGNvbnRyb2wuIFRoaXMgYWRkaXRpb24gd2FzIHJhaXNlZCBieSBTdGVwaGVuIEhhYmVybWFuDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMDYiPjEwNjwvYT5dLg0KICAgICAgPC9saT4gICAgICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIE9HTkwgc3VwcG9ydCBmb3IgcmVuZGVyaW5nIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQ29sdW1uLmh0bWwiPkNvbHVtbjwvYT4NCiAgICAgICB2YWx1ZXMuDQogICAgICA8L2xpPiAgICAgICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgbXVsdGlwbGUgQWN0aW9uTGluayBwYXJhbWV0ZXJzLCBzZWUgDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BYnN0cmFjdExpbmsuaHRtbCNzZXRQYXJhbWV0ZXIoamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLlN0cmluZykiPnNldFBhcmFtZXRlcigpPC9hPg0KICAgICAgIGZvciBkZXRhaWxzLg0KICAgICAgPC9saT4gICAgICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIE1lbnUgDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCNpc1VzZXJJblJvbGVzKCkiPmlzVXNlckluUm9sZXMoKTwvYT4NCiAgICAgICBtZXRob2QuDQogICAgICA8L2xpPiAgICAgICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgDQogICAgICAgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDUuaHRtbCI+QmVzdCBQcmFjdGljZXM8L2E+IHRvcGljIHRvIENsaWNrDQogICAgICAgZG9jdW1lbnRhdGlvbi4NCiAgICAgIDwvbGk+ICAgICAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBGaXhlZCBUb21jYXQgZGVwbG95bWVudCBpc3N1ZSB3aGVyZSBUb21jYXQgQ2xhc3NMb2FkZXIgd2FzIGxvY2tpbmcgQ2xpY2sNCiAgICAgICBKQVJzIHByZXZlbnRpbmcgYXBwbGljYXRpb24gcmVkZXBsb3ltZW50LiBEdWUgbG9ja2luZyBvbiBVUkwgc3RyZWFtcywNCiAgICAgICB0aGUgZGVwbG95bWVudCB0ZWNobmlxdWUgaGFzIHJldmVydGVkIGJhY2sgdG8gdXNpbmcgdW5pcXVlbHkgbmFtZWQgZmlsZXMgKHByZSAwLjE5KS4NCiAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRG95Y2hpDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy04MiI+ODI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgRml4ZWQgTWVzc2FnZXNNYXAgY2FjaGUgcGVybWlzc2lvbnMgaXNzdWUuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgRGF2aWQgRmVsaXMNCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTk5Ij45OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBGaXhlZCBGaWVsZCBzZXRGb2N1cygpIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBEYXZpZCBGZWxpcw0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTAyIj4xMDI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgRml4ZWQgQ29udGV4dCBzZXNzaW9uIExvY2FsZSBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgU3RldmVuIFZhbiBIb29mDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMDciPjEwNzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBGaXhlZCBTZWxlY3QgdmFsaWRhdGlvbiBidWcgd2hlbiBubyBvcHRpb25zIGFyZSBkZWZpbmVkLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMTAiPjExMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBGaXhlZCBEb3VibGVGaWVsZCB2YWxpZGF0aW9uIGJ1ZyB3aXRoICIwIiB2YWx1ZS4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBEYXZpZCBGcml6ZWxsZQ0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTExIj4xMTE8L2E+XS4NCiAgICAgIDwvbGk+ICAgICAgDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgTW92ZWQgQWN0aW9uQnV0dG9uIGNvbnRyb2wgZnJvbSBDbGljayBFeHRyYXMgdG8gY29yZSBjb250cm9scyBwYWNrYWdlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBSZW1vdmVkIGRlcHJlY2lhdGVkIENvbnRleHQgc2Vzc2lvbk9iamVjdCBtZXRob2RzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4yMCAtIDd0aCBKdW5lIDIwMDY8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIGNsaWVudCBzaWRlIEphdmFTY3JpcHQNCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNmb3JtLXZhbGlkYXRpb24iPkZvcm0gVmFsaWRhdGlvbjwvYT4NCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE2Ij4xNjwvYT5dLg0KICAgICAgPC9saT4gICAgICAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIG5ldyBDbGljayBleHRyYXMgY29udHJvbHMNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvQ2hlY2tMaXN0Lmh0bWwiPkNoZWNrTGlzdDwvYT4gYW5kDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0NvbG9yUGlja2VyLmh0bWwiPkNvbG9yUGlja2VyPC9hPi4NCiAgICAgICBUaGVzZSBjb250cm9scyB3ZXJlIGFkZGVkIGJ5IENocmlzdGlhbiBFc3NlbA0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstODEiPjgxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXM9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgYSBnbG9iYWwgcGFnZSBtZXNzYWdlIGJ1bmRsZSwgc2VlIFBhZ2UgDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI2dldE1lc3NhZ2UoamF2YS5sYW5nLlN0cmluZykiPmdldE1lc3NhZ2UoKTwvYT4NCiAgICAgICBmb3IgZGV0YWlscy4gVGhpcyBpc3N1ZSByYWlzZWQgYnkgQ2xhdWRpbyBSb3NzZXR0byANCiAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzIiPjcyPC9hPl0uDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sIj5Db250cm9sPC9hPg0KICAgICAgIDx0dD5wYXJlbnQ8L3R0PiBwcm9wZXJ0eSANCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTg4Ij44ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBzdXBwb3J0IHRhYmxlIENvbHVtbiBzdXBwb3J0IGZvciA8dHQ+amF2YS51dGlsLk1hcDwvdHQ+IHJvdyBvYmplY3RzLg0KICAgICAgIFRoaXMgaXNzdWUgcmFpc2VkIGJ5IEouRi4gWmFyYW1hICANCiAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstOTEiPjkxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIG9wdGlvbiB0byBwbGFjZSBUYWJsZSBiYW5uZXIgb24gdG9wLiANCiAgICAgICBTZWUgVGFibGUNCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1RhYmxlLmh0bWwjYmFubmVyUG9zaXRpb24iPmJhbm5lclBvc2l0aW9uPC9hPg0KICAgICAgIEphdmFkb2MgZm9yIGRldGFpbHMuIFRoaXMgaXNzdWUgcmFpc2VkIGJ5IEouRi4gWmFyYW1hICANCiAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstOTIiPjkyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZCBjb25maWd1cmFibGUgYXBwbGljYXRpb24gTG9jYWxlLiBTZWUgDQogICAgICAgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDRzMDIuaHRtbCNjbGljay1hcHAiPkNsaWNrIEFwcDwvYT4gZm9yDQogICAgICAgZGV0YWlscyBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstOTYiPjk2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yICdQYWdlJyBzdWZmaXggd2hlbiBhdXRvbWFwcGluZyBwYXRoIC0+IGNsYXNzbmFtZS4NCiAgICAgICBTZWUgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDRzMDIuaHRtbCNhcHBsaWNhdGlvbi1hdXRvbWFwcGluZyI+YXV0b21hcHBpbmc8L2E+DQogICAgICAgdG9waWMgZm9yIGRldGFpbHMuIFRoaXMgaXNzdWUgcmFpc2VkIGJ5IFN0ZXBoZW4gSGFiZXJtYW4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIFBhZ2UgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3NldFJlZGlyZWN0KGphdmEubGFuZy5DbGFzcykiPnNldFJlZGlyZWN0KHBhZ2VDbGFzcyk8L2E+DQogICAgICAgbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBGb3JtYXQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Gb3JtYXQuaHRtbCNjdXJyZW50RGF0ZSgpIj5jdXJyZW50RGF0ZSgpPC9hPg0KICAgICAgIG1ldGhvZHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIHJlcXVlc3QgcGFyYW1ldGVyIHRvIENsaWNrU2VydmxldCAgIA0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NsaWNrU2VydmxldC5odG1sI25ld1BhZ2VJbnN0YW5jZShqYXZhLmxhbmcuU3RyaW5nLCBqYXZhLmxhbmcuQ2xhc3MsIGphdmF4LnNlcnZsZXQuaHR0cC5IdHRwU2VydmxldFJlcXVlc3QpIj5uZXdQYWdlSW5zdGFuY2UoKTwvYT4NCiAgICAgICBtZXRob2QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIEJyYXppbGlhbiBwcm9wZXJ0aWVzIGZpbGVzIHByb3ZpZGVkIGJ5IA0KICAgICAgIFJpY2FyZG8gTGVjaGV0YSBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstODYiPjg2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIDxhIHRhcmdldD0iYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NheWVubmUuYXBhY2hlLm9yZy8iPkNheWVubmU8L2E+DQogICAgICAgaW50ZWdyYXRpb24gZXhhbXBsZSB0byBFeGFtcGxlcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgPGEgdGFyZ2V0PSJibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vd3d3LnNwcmluZ3NvdXJjZS5vcmcvIj5TcHJpbmc8L2E+DQogICAgICAgaW50ZWdyYXRpb24gZXhhbXBsZSB0byBFeGFtcGxlcyBhbmQgaW1wcm92ZWQgDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9zcHJpbmcvU3ByaW5nQ2xpY2tTZXJ2bGV0Lmh0bWwiPlNwcmluZ0NsaWNrU2VydmxldDwvYT4NCiAgICAgICBkb2N1bWVudGF0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBJbXByb3ZlZCBWZWxvY2l0eSByZW5kZXJpbmcgcGVyZm9ybWFuY2UuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYW5kIA0KICAgICAgIGZpeGVkIGJ5IFN0ZXBoZW4gSGFiZXJtYW4gDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSdodHRwOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvVkVMT0NJVFktNDM4Jz5WRUxPQ0lUWS00Mzg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgSW1wcm92ZWQgICAgDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9IdG1sU3RyaW5nQnVmZmVyLmh0bWwiPkh0bWxTdHJpbmdCdWZmZXI8L2E+DQogICAgICAgcGVyZm9ybWFuY2Ugd2l0aCB1bnN5bmNocm9uaXplZCBhcHBlbmQgbWV0aG9kcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgSW1wcm92ZWQgQ1NTIGxpbmsgcmVuZGVyaW5nIHRvIGVuYWJsZSBhbHRlcm5hdGUgc3R5bGUgc2hlZXRzLiBUaGlzDQogICAgICAgaXNzdWUgd2FzIHJhaXNlZCBieSBFbnJpY28gRG9uZWxsaQ0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstODEiPjgxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIDx0dD5VbnN1cHBvcnRlZEVuY29kaW5nRXhjZXB0aW9uPC90dD4gaW4gQ2xpY2tVdGlscy5lbmNvZGVVcmwoKSB3aGVuDQogICAgICAgYXBwbGljYXRpb24gY2hhcnNldCBpcyB1bmRlZmluZWQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy04NyI+ODc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgRml4ZWQgZmlsZSBkZXBsb3ltZW50IGlzc3VlIG9uIHNlcnZlcnMgd2l0aCByZXN0cmljdGVkIHBlcm1pc3Npb25zLg0KICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEYXZpZCBGZWxpcw0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstOTUiPjk1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgIFJlbW92ZWQgQ29udHJvbCA8dHQ+cGFyZW50TWVzc2FnZXM8L3R0PiBwcm9wZXJ0eSB3aGljaCB3YXMgZWZmZWN0aXZlbHkNCiAgICAgICByZXBsYWNlZCBieSBuZXcgPHR0PnBhcmVudDwvdHQ+IGFuZCA8dHQ+bWVzc2FnZXM8L3R0PiBwcm9wZXJ0aWVzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBSZW1vdmVkIEZvcm0gc3VwcG9ydCBmb3IgU3RydXRzIHN0eWxlIGVycm9yIG1lc3NhZ2UgcmVuZGVyaW5nLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBVcGRhdGVkIFZlbG9jaXR5IDEuNS1kZXYgSkFSIHNuYXBzaG90IHRvIHJldmlzaW9uIDM5MDczNSwgd2l0aA0KICAgICAgIHBhdGNoIFZFTE9DSVRZLTQzOCBhcHBsaWVkLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBVcGRhdGVkIHBhY2thZ2luZzogPHR0PmNsaWNrLWRvY3VtZW50YXRpb24ud2FyPC90dD4gcmVwbGFjZWQgYnkgDQogICAgICAgIDx0dD5kb2N1bWVudGF0aW9uPC90dD4gZGlyZWN0b3J5IGFuZCA8dHQ+d2ViYXBwcy9jbGljay1leGFtcGxlczwvdHQ+DQogICAgICAgIG1vdmVkIHRvIDx0dD5leGFtcGxlczwvdHQ+IGRpcmVjdG9yeS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMTkgLSA4dGggQXByaWwgMjAwNjwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MC41ZW07Ij4gTmV3IGRldmVsb3Blcg0KICAgIDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdXNlcnMvY2hyaXNpY2hyaXMvIj5DaHJpc3RpYW4gRXNzbDwvYT4NCiAgICBqb2lucyB0aGUgQ2xpY2sgcHJvamVjdC48L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgTmV3IDxhIGhyZWY9Imh0dHA6Ly93d3cuc3Vudm9sdC5jb20vY29uZmx1ZW5jZS9kaXNwbGF5L0NMS1QvQ2xpY2tJREUiPkNsaWNrSURFPC9hPiANCiAgICAgICBFY2xpcHNlIFdUUCBwbHVnLWluIHJlbGVhc2VkIGJ5IE5hb2tpIFRha2V6b2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIG5ldyBDbGljayBFeHRyYXMgY29udHJvbHMgDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BY3Rpb25CdXR0b24uaHRtbCI+QWN0aW9uQnV0dG9uPC9hPiwNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTG9uZ0ZpZWxkLmh0bWwiPkxvbmdGaWVsZDwvYT4sDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL051bWJlckZpZWxkLmh0bWwiPk51bWJlckZpZWxkPC9hPiwNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvVGFiYmVkRm9ybS5odG1sIj5UYWJiZWRGb3JtPC9hPiBhbmQNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvVGVsZXBob25lRmllbGQuaHRtbCI+VGVsZXBob25lRmllbGQ8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBuZXcgQ2xpY2sgRXh0cmFzIENheWVubmUgY29udHJvbHMgDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL1Byb3BlcnR5U2VsZWN0Lmh0bWwiPlByb3BlcnR5U2VsZWN0PC9hPiwNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvUXVlcnlTZWxlY3QuaHRtbCI+UXVlcnlTZWxlY3Q8L2E+IGFuZA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9UYWJiZWRDYXllbm5lRm9ybS5odG1sIj5UYWJiZWRDYXllbm5lRm9ybTwvYT4uDQogICAgICAgQWxzbyBhZGRlZCB3ZWIgDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL0RhdGFDb250ZXh0RmlsdGVyLmh0bWwiPkRhdGFDb250ZXh0RmlsdGVyPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIENvbnRleHQgcGFnZSBwYXRoIGxvb2t1cCBtZXRob2QgDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNnZXRQYWdlUGF0aChqYXZhLmxhbmcuQ2xhc3MpIj5nZXRQYWdlUGF0aCgpPC9hPi4NCiAgICAgICAgVGhpcyBmZWF0dXJlIHdhcyBzdWdnZXN0ZWQgYnkgQ2hyaXN0aWFuIEVzc2wNCiAgICAgICAgWzxhIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY4Ij42ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2RhdGEtYmluZGluZyI+ZGF0YSBiaW5kaW5nPC9hPg0KICAgICAgICBvZiBuZXN0ZWQgb2JqZWN0cyBpbiBmb3JtIGZpZWxkcyB1c2luZyANCiAgICAgICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3d3dy5vZ25sLm9yZyI+T0dOTDwvYT4gbGlicmFyeS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEZvcm0gYnV0dG9uU3R5bGUsIGZpZWxkU3R5bGUgYW5kIGxhYmVsU3R5bGUgYXR0cmlidXRlcyB0byBzdXBwb3J0DQogICAgICAgIGN1c3RvbWlzZWQgZm9ybQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNhdXRvLWxheW91dCI+YXV0byBsYXlvdXRzPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIENvbnRyb2wgVmVsb2NpdHkgdGVtcGxhdGVzIHVzaW5nIG5ldyBDb250ZXh0DQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNyZW5kZXJUZW1wbGF0ZShqYXZhLmxhbmcuQ2xhc3MsIGphdmEudXRpbC5NYXApIj5yZW5kZXJUZW1wbGF0ZSgpPC9hPg0KICAgICAgICBtZXRob2RzLiBTZWUgQ2xpY2sgRXhhbXBsZXMgJ1JpY2ggVGV4dCBBcmVhJyBhbmQgJ1RhYmJlZCBGb3JtJyBmb3IgDQogICAgICAgIGRlbW9uc3RyYXRpb25zLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgcGFnZSBhdXRvbWFwcGluZw0KICAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2FwcGxpY2F0aW9uLWV4Y2x1ZGVzIj5leGNsdWRlczwvYT4uDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgQWhtZWQgTW9ob21iZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUyIj41MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgVGFibGUgY29udHJvbCBtb3VzZW92ZXIgcm93IGhpZ2hsaWdodC4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBBaG1lZCBNb2hvbWJlIGFuZCByZXNvbHZlZCBieSBDaHJpc3RpYW4gRXNzbA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU3Ij41NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIEZyZW5jaCBhbmQgSXRhbGlhbiBwcm9wZXJ0aWVzIGZpbGVzIHByb3ZpZGVkIGJ5IA0KICAgICAgIExvcmVuem8gT3JzZWxsaSBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjUiPjY1PC9hPiwNCiAgICAgICA8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NiI+NjY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NwcmluZy9TcHJpbmdDbGlja1NlcnZsZXQuaHRtbCI+U3ByaW5nQ2xpY2tTZXJ2bGV0PC9hPg0KICAgICAgICBjb25maWd1cmF0aW9uIG9wdGlvbnMgYW5kIGRvY3VtZW50YXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0Zvcm1hdC5odG1sIj5Gb3JtYXQ8L2E+IA0KICAgICAgICBjbGFzcyBub3cgdXNlcyByZXF1ZXN0IGNvbnRleHQgTG9jYWxlLiANCiAgICAgICAgUGxlYXNlIG5vdGUgdGhpcyBjaGFuZ2UgcmVxdWlyZXMgbW9kaWZpY2F0aW9uIHRvIEZvcm1hdCBzdWJjbGFzcw0KICAgICAgICBjb25zdHJ1Y3RvcnMuICAgICAgICANCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzkiPjc5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIFZlbG9jaXR5IGxpYnJhcnkgdG8gbGF0ZXN0IDEuNS1kZXYgYnVpbGQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDEuMkIxLg0KICAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9DYXllbm5lRm9ybS5odG1sIj5DYXllbm5lRm9ybTwvYT4gDQogICAgICAgIGR1cGxpY2F0ZSBpbnNlcnQgYnVnLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5DQogICAgICAgIEJvYiBTY2hlbGxpbmsgWzxhIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYzIj42MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBEYXRlRmllbGQgaW50ZXJuYXRpb25hbGl6YXRpb24gYnVnLiBJc3N1ZSBpZGVudGlmaWVkIGJ5IA0KICAgICAgICBMb3JlbnpvIE9yc2VsbGkgYW5kIGZpeCBwcm92aWRlZCBieSAgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjAiPjYwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXM9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIENsaWNrVXRpbHMgaW52b2tlTGlzdGVuZXIgb24gYW5vbnltb3VzIGlubmVyIGNsYXNzZXMgYnVnLg0KICAgICAgICBUaGlzIGlzc3VlIGlkZW50aWZpZWQgYW5kIGZpeGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03NyI+Nzc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEFjdGlvbkxpbmsgcGFyYW1ldGVyIGVuY29kaW5nIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieQ0KICAgICAgICBTdGV2ZW4gVmFuIEhvb2YgYW5kIGZpeGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzgiPjc4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZW1vdmVkIGV4YW1wbGUgPHR0PmNsaWNrLWJsYW5rPC90dD4gYW5kIDx0dD5jbGljay1jYXllbm5lPC90dD4gYXBwbGljYXRpb25zDQogICAgICAgIGZyb20gbWFpbiBkaXN0cmlidXRpb24uIFRoZXNlIGV4YW1wbGVzIHdpbGwgYmUgcmVsZWFzZWQgYXMgc2VwYXJhdGUgDQogICAgICAgIHBhY2thZ2VzIHVuZGVyIHNvdXJjZWZvcmdlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4xOCAtIDE1dGggSmFudWFyeSAyMDA2PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbTowLjVlbTsiPiBOZXcgZGV2ZWxvcGVyDQogICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy90YWtlem9lLyI+TmFva2kgVGFrZXpvZTwvYT4NCiAgICBqb2lucyB0aGUgQ2xpY2sgcHJvamVjdC48L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIENyZWF0ZWQgbmV3IHBhY2thZ2UgDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9wYWNrYWdlLXN1bW1hcnkuaHRtbCI+b3JnLmFwYWNoZS5jbGljay5leHRyYXMuY29udHJvbDwvYT4NCiAgICAgICAgZm9yIGV4dGVuZGVkIEhUTUwgY29udHJvbHMuIFRoZSBmb2xsb3dpbmcgY29udHJvbHMgaGF2ZSBiZWVuIG1vdmVkDQogICAgICAgIGludG8gdGhpcyBwYWNrYWdlOiBDcmVkaXRDYXJkRmllbGQsIERhdGVGaWVsZCwgRG91YmxlRmllbGQsIEVtYWlsRmllbGQsDQogICAgICAgIEludGVnZXJGaWVsZCBhbmQgTWVudS4NCiAgICAgICAgPHAvPg0KICAgICAgICBUYWJsZSBjb250cm9sIHByb21vdGVkIHRvIGNvcmUgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9wYWNrYWdlLXN1bW1hcnkuaHRtbCI+b3JnLmFwYWNoZS5jbGljay5jb250cm9sPC9hPi4NCiAgICAgICAgPHAvPg0KICAgICAgICBBZGRlZCBDb250cm9sIG1ldGhvZHMgDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNnZXRIdG1sSW1wb3J0cygpIj5nZXRIdG1sSW1wb3J0cygpPC9hPiBhbmQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI29uRGVwbG95KGphdmF4LnNlcnZsZXQuU2VydmxldENvbnRleHQpIj5vbkRlcGxveSgpPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL1BhZ2VJbXBvcnRzLmh0bWwiPlBhZ2VJbXBvcnRzPC9hPg0KICAgICAgICBvYmplY3QgdG8gYXV0b21hdGljYWxseSByZW5kZXIgY29udHJvbCBIVE1MIGhlYWRlciBpbXBvcnRzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgZm9ybSBiYWNrIGJ1dHRvbiBzdXBwb3J0LiBTZWUgRm9ybSANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjb25TdWJtaXRDaGVjayhvcmcuYXBhY2hlLmNsaWNrLlBhZ2UsIGphdmEubGFuZy5TdHJpbmcpIj5vblN1Ym1pdENoZWNrKCk8L2E+DQogICAgICAgIEFQSSBmb3IgZGV0YWlscy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGZ1bGwgSlNQIENsaWNrIFBhZ2UgaW50ZWdyYXRpb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNCI+MjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUmVnZXhGaWVsZC5odG1sIj5SZWdleEZpZWxkPC9hPiANCiAgICAgICAgcHJvdmlkZWQgYnkgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2Ij40NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9Qcm9wZXJ0eVNlbGVjdC5odG1sIj5Qcm9wZXJ0eVNlbGVjdDwvYT4NCiAgICAgICAgcHJvdmlkZWQgYnkgQWhtZWQgTW9ob21iZS4gUGxlYXNlIHNlZSBDbGljayBDYXllbm5lIHdlYiBhcHBsaWNhdGlvbiBmb3INCiAgICAgICAgYSBkZW1vbnN0cmF0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgSmFwYW5lc2UgbWVzc2FnZSByZXNvdXJjZXMgcHJvdmlkZWQgYnkgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ0Ij40NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgR2VybWFuIG1lc3NhZ2UgcmVzb3VyY2VzIHByb3ZpZGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTUiPjU1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBjbGljay1leGFtcGxlcyBUYWJsZSB3aXRoIEZvcm0gZmllbGRzIGRlbW9uc3RyYXRpb24gcHJvdmlkZWQgYnkgDQogICAgICAgIENocmlzdGlhbiBFc3NsLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgVVRGLTggY2hhcnNldCBoYW5kbGluZyBwcm92aWRlZCBieSBOYW9raSBUYWtlem9lIA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU2Ij41NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgRm9ybSAmbHQ7LSZndDsgREFPICBhdXRvLWxvYWRpbmcgdG8gaGFuZGxlIHByaW1pdGl2ZSB0eXBlcy4gDQogICAgICAgIFByb3ZpZGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTMiPjUzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIGNvbW1vbnMtZmlsZXVwbG9hZCB0byB2ZXJzaW9uIDEuMSBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ5Ij40OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgbnVsbCBDb2x1bW4gRGVjb3JhdG9yIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBHZW9mZiBIb3Bzb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MCI+NDA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFRhYmxlIHBhZ2luZyBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgQWhtZWQgTW9ob21iZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQxIj40MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgVGV4dEZpZWxkIGNvbnN0cnVjdG9yIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBCb2IgU2NoZWxsaW5rDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDIiPjQyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBKU0NhbGVuZGFyIHByb2JsZW0gaW4gSmFwYW5lc2UuIFRoaXMgZml4IHdhcyBwcm92aWRlZCBieQ0KICAgICAgICBOYW9raSBUYWtlem9lDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDMiPjQzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBGb3JtIEZpZWxkU2V0IEZpbGVGaWVsZCBlbmN0eXBlIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieQ0KICAgICAgICBDaHJpc3RpYW4gRXNzbA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ4Ij40ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgc2Vzc2lvbiByZXdyaXRlIGJ1ZyB3aGVuIHVzaW5nIGFic29sdXRlIHJlZGlyZWN0cy4gDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgTWFpayBKYWJsb25za2kNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01MSI+NTE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFZlbG9jaXR5IFJ1bnRpbWVFeGNlcHRpb24gaGFuZGxpbmcgYnVnDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cDovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL1ZFTE9DSVRZLTQyNCI+VkVMT0NJVFktNDI0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBWZWxvY2l0eSAxLjUtZGV2IGFuZCBDYXllbm5lIDEuMiBpbnRlcm9wZXJhYmlsaXR5IGJ1ZyANCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvVkVMT0NJVFktNDI2Ij5WRUxPQ0lUWS00MjY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMTcgLSA1dGggRGVjZW1iZXIgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIE1vZGlmaWVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NsaWNrU2VydmxldC5odG1sIj5DbGlja1NlcnZsZXQ8L2E+IA0KICAgICAgICB0byBlbmFibGUgZGlyZWN0IFNlcnZsZXRSZXNwb25zZSBoYW5kbGluZyBieSANCiAgICAgICAgUGFnZXMuIFNlZSBDbGljayBFeGFtcGxlcyBEaXJlY3QgUGFnZSBmb3IgYSBkZW1vbnN0cmF0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTW9kaWZpZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9zcHJpbmcvU3ByaW5nQ2xpY2tTZXJ2bGV0Lmh0bWwiPlNwcmluZ0NsaWNrU2VydmxldDwvYT4NCiAgICAgICAgdG8gc2V0IFNwcmluZyBBcHBsaWNhdGlvbkNvbnRleHQgaW4gcGFnZXMgaW1wbGVtZW50aW5nIA0KICAgICAgICA8dHQ+QXBwbGljYXRpb25Db250ZXh0QXdhcmU8L3R0PiBpbnRlcmZhY2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDbGljayAwLjE2IGludGVncmF0aW9uIGlzc3VlcyB3aXRoIFZlbG9jaXR5IDEuNS1kZXYgc25hcHNob3QgYW5kIA0KICAgICAgICBDYXllbm5lIDEuMi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlZ2lzdGVyZWQgQ2xpY2sgSkFScyB3aXRoICANCiAgICAgICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3d3dy5pYmlibGlvLm9yZy9tYXZlbi9uZXQuc2YuY2xpY2svamFycy8iPkliaWJsaW8gTWF2ZW48L2E+IFJlcG9zaXRvcnkuDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4xNiAtIDJuZCBEZWNlbWJlciAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgY29udHJvbCBsb2NhbGl6YXRpb24gc3VwcG9ydCwgcGxlYXNlIHNlZSANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI2dldExhYmVsKCkiPkZpZWxkPC9hPg0KICAgICAgICBKYXZhZG9jIGFuZCA8YSBocmVmPSJmYXEuaHRtbCNsb2NhbGl6YXRpb24iPkZBUTwvYT4gZm9yIGRldGFpbHMuDQogICAgICAgIDxwLz4NCiAgICAgICAgVGhpcyBmZWF0dXJlIGJhc2VkIG9uIGEgY29uY2VwdCBkZXZlbG9wZWQgYnkgQWhtZWQgTW9ob21iZSwNCiAgICAgICAgYW5kIHJlcGxhY2VzIHRoZSA8dHQ+Im1zZzoiPC90dD4gcHJlZml4IGxvY2FsaXphdGlvbiBmdW5jdGlvbmFsaXR5DQogICAgICAgIGludHJvZHVjZWQgaW4gcmVsZWFzZSAwLjEzLiANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEhpYmVybmF0ZSBkYXRhIGF3YXJlIEZvcm0gY29udHJvbA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2hpYmVybmF0ZS9IaWJlcm5hdGVGb3JtLmh0bWwiPkhpYmVybmF0ZUZvcm08L2E+LA0KICAgICAgICBhbmQgc3VwcG9ydGluZw0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2hpYmVybmF0ZS9TZXNzaW9uQ29udGV4dC5odG1sIj5TZXNzaW9uQ29udGV4dDwvYT4gYW5kDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvaGliZXJuYXRlL1Nlc3Npb25GaWx0ZXIuaHRtbCI+U2Vzc2lvbkZpbHRlcjwvYT4gY2xhc3Nlcy4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBNZW51IA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTWVudS5odG1sI3BhZ2VzIj5wYWdlczwvYT4NCiAgICAgICAgcHJvcGVydHkgZm9yIHNlbGVjdGluZyBtZW51IGl0ZW1zLiBUaGlzIGZlYXR1cmUgd2FzIHByb3ZpZGVkIGJ5IA0KICAgICAgICBHZW9mZiBIb3Bzb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zOSI+Mzk8L2E+XS4NCiAgICAgICAgPHAvPg0KICAgICAgICBSZWZhY3RvcmVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9NZW51Lmh0bWwiPk1lbnU8L2E+DQogICAgICAgIHRvIGltcGxlbWVudCBDb250cm9sIGludGVyZmFjZSB0byBpbXByb3ZlIFBhZ2Ugc3ViY2xhc3NpbmcuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBGb3JtIHJlbmRlcmluZyBmbGV4aWJpbGl0eSB3aXRoIG5ldyBwcm9wZXJ0aWVzDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2dldExhYmVsUmVxdWlyZWRQcmVmaXgoKSI+bGFiZWxSZXF1aXJlZFByZWZpeDwvYT4NCiAgICAgICAgYW5kDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2dldExhYmVsUmVxdWlyZWRTdWZmaXgoKSI+bGFiZWxSZXF1aXJlZFN1ZmZpeDwvYT4uICAgICAgICANCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1NlbGVjdC5odG1sI3NldE11bHRpcGxlVmFsdWVzKGphdmEudXRpbC5MaXN0KSI+U2VsZWN0PC9hPg0KICAgICAgICA8dHQ+c2V0TXVsdGlwbGVWYWx1ZXMoKTwvdHQ+IG1ldGhvZC4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieQ0KICAgICAgICBHZW9mZiBIb3Bzb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNCI+MzQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIENvbnRleHQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI2NyZWF0ZVBhZ2UoamF2YS5sYW5nLkNsYXNzKSI+Y3JlYXRlUGFnZSgpPC9hPg0KICAgICAgICBtZXRob2QgZW5hYmxpbmcgeW91IHRvIHNwZWNpZnkgdGhlIHRhcmdldCBwYWdlIGJ5IGNsYXNzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZCBjdXN0b20gcmljaCB0ZXh0IGFyZWEgY29udHJvbCBkZW1vbnN0cmF0aW9uIA0KICAgICAgICBpbiBDbGljayBFeGFtcGxlcyBFbWFpbCBGb3JtIHBhZ2UuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgQ29sdW1uIG51bGwgdmFsdWUgaGFuZGxpbmcgYnVnLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5DQogICAgICAgIEdlb2ZmIEhvcHNvbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyIj4zMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgQWN0aW9uTGluayB2YWx1ZSBlc2NhcGluZyBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkNCiAgICAgICAgR2VvZmYgSG9wc29uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzMiPjMzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBEYXRlRmllbGQgSTE4TiBpc3N1ZSBhbmQgaW1wcm92ZWQgcmVuZGVyaW5nLiBUaGVzZSBpc3N1ZXMgd2VyZSANCiAgICAgICAgaWRlbnRpZmllZCBieSBBbnRvbmkgQWxveSBhbmQgQWhtZWQgTW9ob21iZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM2Ij4zNjwvYT4sDQogICAgICAgICA8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjciPjI3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBNb2RpZmllZCBGb3JtYXQgDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvRm9ybWF0Lmh0bWwjZ2V0RW1wdHlTdHJpbmcoKSI+Z2V0RW1wdHlTdHJpbmcoKTwvYT4NCiAgICAgICAgdG8gcmV0dXJuICIiIHN0cmluZ3MgdG8gYmV0dGVyIHN1cHBvcnQgQUpBWCByZW5kZXJpbmcuIA0KICAgICAgICBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IEFuZHJ1cyBBZGFtY2hpay4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+IA0KICA8ZHQ+VmVyc2lvbiAwLjE1IC0gMjV0aCBPY3RvYmVyIDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBlc2NhcGluZyBxdW90ZSBjaGFyYWN0ZXJzIGluIGNvbnRyb2xzLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5DQogICAgICAgIE1pa2UgT3JnYW5law0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxIj4zMTwvYT5dLjxici8+DQogICAgICAgIEFkZGVkIG5ldyANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9IdG1sU3RyaW5nQnVmZmVyLmh0bWwiPkh0bWxTdHJpbmdCdWZmZXI8L2E+DQogICAgICAgIGNsYXNzIGZvciBjb250cm9sIHJlbmRlcmluZy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGNsaWNrLWNheWVubmUgPGEgaHJlZj0iZXhhbXBsZXMuaHRtbCI+ZXhhbXBsZTwvYT4gd2ViIGFwcGxpY2F0aW9uLiANCiAgICAgICAgVGhpcyBhcHBsaWNhdGlvbiB3YXMgY29udHJpYnV0ZWQgYnkgQW5kcnVzIEFkYW1jaGlrLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlZmFjdG9yZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwiPkZvcm08L2E+IA0KICAgICAgICBhbGlnbiBhbmQgcG9zaXRpb24gY29uc3RhbnRzIHRvIHJlbW92ZSBhbWJpZ3VpdHkuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgQ2xpY2tBcHAgTlBFIHdoZW4gaW5pdGlhbGl6aW5nDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzAiPjMwPC9hPl0sDQogICAgICAgIHJlbGF0ZWQgVmVsb2NpdHkgRW5naW5lIHBhdGNoZXMgYXBwbGllZCANCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvVkVMT0NJVFktNDEyIj40MTI8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZWZhY3RvcmVkIEFudCBidWlsZCBzeXN0ZW0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxkdD5WZXJzaW9uIDAuMTQgLSAxN3RoIE9jdG9iZXIgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MC41ZW07Ij4gTmV3IGRldmVsb3Blcg0KICAgIDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdXNlcnMvYW1vaG9tYmUvIj5BaG1lZCBNb2hvbWJlPC9hPg0KICAgIGpvaW5zIHRoZSBDbGljayBwcm9qZWN0LjwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRmllbGRTZXQgRm9ybSBwcm9jZXNzaW5nIGJ1Zy4gVGhlIGJ1ZyB3YXMgaWRlbnRpZmllZCBieSBieSBQYXVsIFJ1bGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNSI+MjU8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZW1vdmVkIEpET00gZGVwZW5kZW5jeS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBWZWxvY2l0eSBFbmdpbmUgZXJyb3IgcmVwb3J0aW5nIHBhdGNoZXMgYXBwbGllZCANCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvVkVMT0NJVFktMzczIj4zNzM8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBNb2RpZmllZCBBbnQgYnVpbGQgc2NyaXB0IHRvIGRvd25sb2FkIEpBUiBkZXBlbmRlbmNpZXMgZnJvbSANCiAgICAgICAgPGEgaHJlZj0iaHR0cDovL3d3dy5pYmlibGlvLm9yZy9tYXZlbi8iPkliaWJsaW88L2E+IE1hdmVuIHJlcG9zaXRvcnkuDQogICAgICA8L2xpPiAgICANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8ZHQ+VmVyc2lvbiAwLjEzIC0gMTN0aCBPY3RvYmVyIDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBTcHJpbmcgaW50ZWdyYXRpb24gc2VydmxldA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NwcmluZy9TcHJpbmdDbGlja1NlcnZsZXQuaHRtbCI+U3ByaW5nQ2xpY2tTZXJ2bGV0PC9hPi4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBDYXllbm5lIGRhdGEgYXdhcmUgRm9ybSBjb250cm9sDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9DYXllbm5lRm9ybS5odG1sIj5DYXllbm5lRm9ybTwvYT4uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgSlNQIHN1cHBvcnQuIFNlZSANCiAgICAgICAgPGEgaHJlZj0iZmFxLmh0bWwjanNwLXN1cHBvcnQiPkZBUTwvYT4NCiAgICAgICAgZm9yIGRldGFpbHMgYW5kIENsaWNrIEV4YW1wbGVzIGZvciBhIGRlbW9uc3RyYXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCANCgk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwjc2V0TGFiZWwoamF2YS5sYW5nLlN0cmluZykiPkZpZWxkPC9hPg0KCWxvY2FsaXphdGlvbiBzdXBwb3J0LCBzZWUgPGEgaHJlZj0iZmFxLmh0bWwjbG9jYWxpemF0aW9uIj5GQVE8L2E+IGZvciBkZXRhaWxzLg0KCUJhc2VkIG9uIGEgY29uY2VwdCBieSBJYWluIFNoaWdlb2thLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRmllbGRTZXQgRm9ybSAmbHQ7LSZndDsgREFPIGF1dG8tbG9hZGluZyBidWcuIFRoZSBmaXggd2FzIHByb3ZpZGVkIA0KICAgICAgICBieSBQYXVsIFJ1bGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMCI+MjM8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBXZWJTcGhlcmUncyBidW5kbGVkIEpET00gMC43IGNvbXBhdGliaWxpdHkgaXNzdWUuIFRoaXMgaXNzdWUgd2FzDQogICAgICAgIGlkZW50aWZpZWQgYnkgT2xpdmVyIEJ1cm4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMCI+MjU8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIEpha2FydGEgQ29tbW9ucyBKQVJzIHRvIGxhdGVzdCB2ZXJzaW9ucyB0byBzdXBwb3J0IEhpYmVybmF0ZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE5Ij4xOTwvYT5dLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlbW92ZWQgQ29tbW9ucyBMb2dnaW5nIGRlcGVuZGVuY3kgaW4gQ2xpY2sgRXh0cmFzIHRvIGF2b2lkIFdlYlNwaGVyZQ0KICAgICAgICBjbGFzcyBsb2FkaW5nIGlzc3Vlcw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIwIj4yMDwvYT5dLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgVmVsb2NpdHkgMS41IGRldiBidWlsZCB0byB1c2UgcmVjZW50IHNuYXBzaG90DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjEiPjIxPC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgTlBFIGJ1ZyBpbiBFcnJvclJlcG9ydC4gVGhpcyBmaXggd2FzIHByb3ZpZGVkIGJ5IFN0ZXZlIENvd3guDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4xMiAtIDFzdCBPY3RvYmVyIDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGRTZXQuaHRtbCI+RmllbGRTZXQ8L2E+IA0KICAgICAgICBjb250cm9sLiBTZWUgSmF2YWRvYyBmb3IgZGV0YWlscyBhbmQgQ2xpY2sgRXhhbXBsZXMgZm9yIGEgZGVtb25zdHJhdGlvbiANCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQiPkNMSy00PC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkIEZpZWxkIDx0dD4ibmFtZSI8L3R0PiBhbmQgPHR0PiJsYWJlbCI8L3R0PiBjb25zdHJ1Y3RvcnMgYWRkZWQgdG8gDQogICAgICAgIG1ha2UgRm9ybSAmbHQ7LSZndDsgREFPIGF1dG8tbG9hZGluZyBlYXNpZXIgdG8gdXNlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQ2hhbmdlZCBjb250cm9scyB0byByZW5kZXIgdmFsaWQgWEhUTUwsIGluc3RlYWQgb2YgSFRNTCA0LjAxLCBlbmFibGluZw0KICAgICAgICBGaXJlZm94IGFuZCBNYWMgT1MgWCAgYnJvd3NlcnMgdG8gcmVuZGVyIEFKQVggcmVzcG9uc2VzIGNvbnRhaW5pbmcgQ29udHJvbA0KICAgICAgICBIVE1MDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMyI+Q0xLLTM8L2E+XS4NCiAgICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgICBGb3IgZXhhbXBsZSB0aGUgVGV4dEZpZWxkIEhUTUwgJm5ic3A7IDx0dD4mbHQ7aW5wdXQgdHlwZT0ndGV4dCcgZGlzYWJsZWQmZ3Q7PC90dD4gDQogICAgICAgICZuYnNwOyBub3cgcmVuZGVycyBhcyA8YnIvPiA8dHQ+Jmx0O2lucHV0IHR5cGU9J3RleHQnIGRpc2FibGVkPSdkaXNhYmxlZCcvJmd0OzwvdHQ+IDwvZGl2Pg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgYnVnIHdoZXJlIG11bHRpcGFydCBmb3JtIHBhcmFtZXRlcnMgbm90IGF2YWlsYWJsZSBkdXJpbmcgDQogICAgICAgIDx0dD5QYWdlLm9uSW5pdCgpPC90dD4gDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMSI+Q0xLLTE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMTEgLSAxNnRoIFNlcHRlbWJlciAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTWVudS5odG1sIj5NZW51PC9hPiBjb21wb25lbnQuDQogICAgICAJU2VlIEphdmFkb2MgZm9yIGRldGFpbHMgYW5kIENsaWNrIEV4YW1wbGVzIGZvciBhIGRlbW9uc3RyYXRpb24gDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMiI+Q0xLLTEyPC9hPl0uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBydW50aW1lIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAyLmh0bWwjcGFnZS1hdXRvLWxvYWRpbmciPlBhZ2UgQXV0byBMb2FkaW5nPC9hPg0KICAgICAgICB3aGVuIHRoZSBhcHBsaWNhdGlvbiBpcyBpbg0KICAgICAgICA8dHQ+ImRldmVsb3BtZW50IjwvdHQ+LCA8dHQ+ImRlYnVnIjwvdHQ+IG9yIDx0dD4idHJhY2UiPC90dD4gbW9kZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE4Ij5DTEstMTg8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIEZvcm0gJmx0Oy0mZ3Q7IERBTyBhdXRvLWxvYWRpbmcgZmVhdHVyZS4NCiAgICAgICAgU2VlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2NvcHlGcm9tKGphdmEubGFuZy5PYmplY3QpIj5Gb3JtPC9hPg0KICAgICAgICBKYXZhZG9jIGZvciBkZXRhaWxzIFs8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yIj5DTEstMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgYmxhbmsgcGFnZSBnemlwIGNvbXByZXNzaW9uIGJ1Zy4gVGhlIENsaWNrIGVtYmVkZGVkIGd6aXAgY29tcHJlc3Npb24gDQogICAgICAgIGZ1bmN0aW9uYWxpdHkgaGFzIGJlZW4gcmVwbGFjZWQgd2l0aCBhDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvZmlsdGVyL0NvbXByZXNzaW9uRmlsdGVyLmh0bWwiPkNvbXByZXNzaW9uRmlsdGVyPC9hPg0KICAgICAgICBkZXJpdmVkIGZyb20gSmFya2F0YSBUb21jYXQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01Ij5DTEstNTwvYT5dLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIDx0dD5lbWFpbCgpPC90dD4gYW5kIDx0dD5saW5rKCk8L3R0PiBmb3JtYXR0ZXIgbWV0aG9kcyBhbmQNCiAgICAgICAgPHR0PmdldEVtcHR5U3RyaW5nKCk8L3R0PiBtZXRob2QgdG8NCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Gb3JtYXQuaHRtbCNlbWFpbChqYXZhLmxhbmcuU3RyaW5nKSI+Rm9ybWF0PC9hPiBjbGFzcw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE1Ij5DTEstMTU8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBNb2RpZmllZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCI+Rm9ybTwvYT4NCiAgICAgICAgY29udHJvbCB0byByZW5kZXIgYSBjbGFzcyBlcnJvciBhdHRyaWJ1dGUgJmx0O2xhYmVsIGNsYXNzPSJlcnJvciImZ3Q7IA0KICAgICAgICBpbiB0aGUgbGFiZWxzIG9mIGludmFsaWQgZmllbGRzLiBZb3UgY2FuIG5vdyBvdmVycmlkZSB0aGUgPHR0PmNvbnRyb2wuY3NzPC90dD4NCiAgICAgICAgc3R5bGUgPHR0PmxhYmVsLmVycm9yPC90dD4gdG8gbW9kaWZ5IHRoZSBkaXNwbGF5IG9mIGZpZWxkIGVycm9yIGxhYmVscy4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBNb2RpZmllZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNGb3JtKGphdmEubGFuZy5TdHJpbmcpIj5Gb3JtPC9hPg0KICAgICAgICBjb25zdHJ1Y3RvciB0byBvbmx5IHJlcXVpcmUgZm9ybSBuYW1lIHBhcmFtZXRlci4gVGhlIGNvbnRleHQgY2FuIGJlDQogICAgICAgIHNldCBsYXRlci4gTm90ZSB0aGlzIHdpbGwgcmVxdWlyZSBtb2RpZmljYXRpb25zIHRvIGV4aXRpbmcgY29kZS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjEwIC0gMXN0IFNlcHRlbWJlciAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbTowLjVlbTsiPiBOZXcgZGV2ZWxvcGVyDQogICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9wYmFybmVzLyI+UGhpbCBCYXJuZXM8L2E+IA0KICAgIGpvaW5zIHRoZSBDbGljayBwcm9qZWN0LjwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3BhbmVsL3BhY2thZ2Utc3VtbWFyeS5odG1sIj5QYW5lbDwvYT4gDQogICAgICAgIGNvbXBvbmVudHMgYnkgUGhpbCBCYXJuZXMuIFNlZSBKYXZhZG9jIGZvciBkZXRhaWxzIGFuZCBDbGljayBFeGFtcGxlcyBmb3IgYSBkZW1vbnN0cmF0aW9uLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9UYWJsZS5odG1sIj5UYWJsZTwvYT4gY29udHJvbC4NCiAgICAgIAlTZWUgSmF2YWRvYyBmb3IgZGV0YWlscyBhbmQgQ2xpY2sgRXhhbXBsZXMgZm9yIGEgZGVtb25zdHJhdGlvbiANCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdHJhY2tlci9pbmRleC5waHA/ZnVuYz1kZXRhaWwmYWlkPTEyNDMyNDMmZ3JvdXBfaWQ9ODIwOTUmYXRpZD01NjUwMjciPjEyNDMyNDM8L2E+XS4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvSW1hZ2VTdWJtaXQuaHRtbCI+SW1hZ2VTdWJtaXQ8L2E+IA0KICAgICAgICBjb250cm9sIGJ5IFBoaWwgQmFybmVzLiBTZWUgSmF2YWRvYyBmb3IgZGV0YWlscyBhbmQgQ2xpY2sgRXhhbXBsZXMgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBMb2NhbGl6YXRpb24vSTE4TiBjaGFuZ2VzIGluY2x1ZGU6DQogICAgICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgICAgQWRkZWQgQ2hpbmVzZSBsb2NhbGl6YXRpb24gcHJvcGVydGllcyAoemhfQ04pIHByb3ZpZGVkIGJ5IFhpIFBpbmcgV2FuZy4gPC9kaXY+DQogICAgICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgICAgQWRkZWQgUGFnZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL01lc3NhZ2VzTWFwLmh0bWwiPk1lc3NhZ2VzTWFwPC9hPg0KICAgICAgICBhZGFwdG9yIHRvIFZlbG9jaXR5IENvbnRleHQuDQogICAgICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgIAlBZGRlZCBuZXcgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI2dldExvY2FsZSgpIj5nZXRMb2NhbGUoKTwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNzZXRMb2NhbGUoamF2YS51dGlsLkxvY2FsZSkiPnNldExvY2FsZSgpPC9hPg0KICAgICAgICBtZXRob2RzIHRvIENvbnRleHQgY2xhc3MgdG8gZW5hYmxlIG92ZXJyaWRpbmcgdGhlIGRlZmF1bHQgcmVxdWVzdCBMb2NhbGUuIDwvZGl2Pg0KICAgICAgPC9saT4gIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCU5ldyA8YSBocmVmPSJleHRyYXMtYXBpL292ZXJ2aWV3LXN1bW1hcnkuaHRtbCI+Q2xpY2sgRXh0cmFzPC9hPiBtb2R1bGUgYW5kIEpBUiBwcm92aWRlZCBmb3INCiAgICAgICAgY29udHJpYnV0aW9ucyBhbmQgbm9uLWNvcmUgZnJhbWV3b3JrIGNvbXBvbmVudHMuDQogICAgICA8L2xpPiAgIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCU5ldyBSaWNvIGluc3BpcmVkIEFKQVggTGl2ZSBHcmlkIGV4YW1wbGUgcHJvdmlkZWQgYnkgUGhpbCBCYXJuZXMuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlDbGljayBFeGFtcGxlcywgQ29uZmx1ZW5jZSBXSUtJIGFuZCBKSVJBIGFwcGxpY2F0aW9ucyBhcmUgbm93IGF2YWlsYWJsZSBvbmxpbmUuIA0KICAgICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOjAuNWVtOyI+DQogICAgICAgIFNwZWNpYWwgdGhhbmtzIHRvIFBoaWwgQmFybnMgZm9yIGhvc3RpbmcgdGhlc2UgYXBwbGljYXRpb25zLiA8L2Rpdj4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gDQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjkgLSA3dGggQXVndXN0IDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIGFwcGxpY2F0aW9uIHJlbG9hZGluZyBmZWF0dXJlIHRvIHJlbG9hZCAiY2xpY2sueG1sIiB3aXRob3V0DQogICAgICAJcmVzdGFydGluZyB0aGUgd2ViIGFwcGxpY2F0aW9uLg0KICAgICAgCVNlZSANCiAgICAgIAk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNhcHAtcmVsb2FkaW5nIj5DbGlja1NlcnZsZXQ8L2E+DQogICAgICAJSmF2YWRvYyBmb3IgZGV0YWlscyBhbmQgdGhlIENsaWNrIEV4YW1wbGVzIGZvciBhIGRlbW9uc3RyYXRpb24gDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3RyYWNrZXIvaW5kZXgucGhwP2Z1bmM9ZGV0YWlsJmFpZD0xMjUwOTc4Jmdyb3VwX2lkPTgyMDk1JmF0aWQ9NTY1MDI3Ij4xMjM3OTQyPC9hPl0uDQogICAgICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgICAgVGhpcyBjb25jZXB0IHdhcyBkZWZpbmVkIGJ5IDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdXNlcnMvaGFuc2JhZWNrZXJtLyI+SGFucyBCYWVja2VyLU1heWVyPC9hPi4gPC9kaXY+DQogICAgICA8L2xpPiAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC44IC0gMm5kIEF1Z3VzdCAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9zZXJ2aWNlL0xvZ1NlcnZpY2UuaHRtbCI+TG9nU2VydmljZTwvYT4NCiAgICAgIAl3aGljaCBsb2dzIHRvIHRoZSBjb25zb2xlIGJ5IGRlZmF1bHQuIA0KICAgICAgCVNlZSB0aGUgQ2xpY2sgYW5kICBWZWxvY2l0eSA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2NsaWNrLWxvZ2dpbmciPkxvZ2dpbmc8L2E+DQogICAgICAJdG9waWMuDQogICAgICA8L2xpPiAgICANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC43IC0gMjh0aCBKdWx5IDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIA0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWxlRmllbGQuaHRtbCI+RmlsZUZpZWxkPC9hPg0KICAgICAgICAgY29udHJvbCBmb3IgdXBsb2FkaW5nIGZpbGVzIGFuZCBtb2RpZmllZCBGb3JtIGNvbnRyb2wgdG8gc3VwcG9ydCANCiAgICAgICAgICJtdWx0aXBhcnQvZm9ybS1kYXRhIiByZXF1ZXN0cy4gU2VlIHRoZSBDbGljayBFeGFtcGxlcyANCiAgICAgICAgIEZpbGUgVXBsb2FkIHBhZ2UgZm9yIGEgZGVtb25zdHJhdGlvbiBbPGEgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC90cmFja2VyL2luZGV4LnBocD9mdW5jPWRldGFpbCZhaWQ9MTIzNzk0MiZncm91cF9pZD04MjA5NSZhdGlkPTU2NTAyNyI+MTIzNzk0MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlcyI+DQogICAgICAgIEFkZGVkIHBhZ2VzIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAyLmh0bWwjYXBwbGljYXRpb24tYXV0b21hcHBpbmciPkF1dG8gTWFwcGluZzwvYT4NCiAgICAgICAgY29uZmlndXJhdGlvbiBvcHRpb24uIFRoaXMgZmVhdHVyZSBjYW4gYXV0b21hdGljYWxseSBtYXAgSFRNTCBwYWdlDQogICAgICAgIHRlbXBsYXRlcyB0byBQYWdlIGNsYXNzZXMgc28geW91IGRvbid0IGhhdmUgdG8gZGVjbGFyZSB0aGVtIG1hbnVhbGx5IGluDQogICAgICAgIHRoZSBjbGljay54bWwgY29uZmlndXJhdGlvbiBmaWxlLiANCiAgICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgICBUaGlzIGNvbmNlcHQgd2FzIGRlZmluZWQgYnkgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9hbW9ob21iZS8iPkFobWVkIE1vaG9tYmU8L2E+LiA8L2Rpdj4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZXMiPg0KICAgICAgICBBZGRlZCANCiAgICAgICAgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDJzMDUuaHRtbCNwYWdlLWZvcndhcmRpbmciPlBhZ2UgRm9yd2FyZGluZzwvYT4NCiAgICAgICAgZW5hYmxpbmcgeW91IHRvIGNvbmZpZ3VyZSB0aGUgUGFnZSB0byBmb3J3YXJkIHRoZSByZXF1ZXN0IHRvLg0KICAgICAgICBUaGlzIHByb3ZpZGVzIHNpbWlsYXIgZnVuY3Rpb25hbGl0eSBhcyBUYXBlc3RyeSdzIDx0dD5jeWNsZS5nZXRQYWdlKCk8L3R0Pg0KICAgICAgICBpbnRlcnBhZ2UgY2FsbGluZyB0ZWNobmlxdWUuIFNlZSB0aGUgRXhhbXBsZXMgUGFnZQ0KICAgICAgICBGbG93IGZvciBhIGRlbW9uc3RyYXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2VzIj4NCiAgICAgICAgQWRkZWQgDQogICAgICAgIENsaWNrU2VydmxldCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNuZXdQYWdlSW5zdGFuY2UoamF2YS5sYW5nLkNsYXNzLCBqYXZheC5zZXJ2bGV0Lmh0dHAuSHR0cFNlcnZsZXRSZXF1ZXN0KSI+bmV3UGFnZUluc3RhbmNlKCk8L2E+DQogICAgICAgIG1ldGhvZCB0byBzdXBwb3J0IElvQyBhcHBsaWNhdGlvbnMuIFNlZSB0aGUgDQogICAgICAgIDxhIGhyZWY9ImZhcS5odG1sI3NwcmluZy1pbnRlZ3JhdGlvbiI+U3ByaW5nIEludGVncmF0aW9uPC9hPiBGQVEgdG9waWMgZm9yIG1vcmUgZGV0YWlscy4NCiAgICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgICBUaGlzIGNvbmNlcHQgd2FzIGRlZmluZWQgYnkgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9wYmFybmVzLyI+UGhpbCBCYXJuZXM8L2E+LiA8L2Rpdj4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZXMiPg0KICAgICAgICBGb3JtIHJlbmRlcmluZyBpbXByb3ZlZCB0byBpbmNsdWRlIENTUyBjbGFzc2VzICJmaWVsZHMiLCAiZXJyb3JzIiBhbmQgImJ1dHRvbnMiIA0KICAgICAgICBpbiB0aGUgcmVzcGVjdGl2ZSB0YWJsZSAmbHQ7dHImZ3Q7IGFuZCAmbHQ7dGQmZ3Q7IGVsZW1lbnRzLiBUaGlzIGVuYWJsZXMgZ3JlYXRlcg0KICAgICAgICBjb250cm9sIG9mIEZvcm0gZGlzcGxheSB1c2luZyBDU1Mgc3R5bGVzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgInRyYWNlIiBhcHBsaWNhdGlvbiBtb2RlIHRvIHByb3ZpZGUgbW9yZSBkZXRhaWxlZCBsb2dnaW5nLg0KICAgICAgICBTZWUgdGhlIENvbmZpZ3VyYXRpb24gPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDRzMDIuaHRtbCNhcHBsaWNhdGlvbi1tb2RlIj5Nb2RlPC9hPiB0b3BpYy4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCANCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Gb3JtYXQuaHRtbCNsaW1pdExlbmd0aChqYXZhLmxhbmcuU3RyaW5nLCBpbnQpIj5saW1pdExlbmd0aCgpPC9hPg0KICAgICAgICBtZXRob2RzIHRvIHRoZSBGb3JtYXQgY2xhc3MuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBTdWJtaXQgY29udHJvbHMgcHJvY2Vzc2luZyBvZiBIVE1MIGNoYXJhY3RlcnMuDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+IA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC42IC0gMm5kIEp1bHkgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+QWRkZWQgQUpBWCBEeW5hbWljIEhUTUwgYW5kIFhNTCByZXF1ZXN0IGV4YW1wbGUgdXNpbmcNCiAgICAgICAgIHRoZSB1c2luZyBSaWNvIEFqYXggbGlicmFyeS4gU2VlIHRoZSBDbGljayBFeGFtcGxlcyBBSkFYIHBhZ2UgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9PcHRpb24uaHRtbCI+T3B0aW9uPC9hPiBhbmQgDQogICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL09wdGlvbkdyb3VwLmh0bWwiPk9wdGlvbkdyb3VwPC9hPiANCiAgICAgICAgICByZWZhY3RvcmVkIGludG8gc3RhbmRhbG9uZSBjbGFzc2VzLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICBBZGRlZCBQYWdlIA0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3NldEhlYWRlcihqYXZhLmxhbmcuU3RyaW5nLCBqYXZhLmxhbmcuT2JqZWN0KSI+c2V0SGVhZGVyKCk8L2E+DQogICAgICAgICBtZXRob2QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkZpeGVkIE5QRSB3aGVuIEZpZWxkcywgd2l0aCBubyBwYXJlbnQgRm9ybSwgYXJlIHByb2Nlc3NlZA0KICAgICAgICAgYW5kIHJlbmRlcmVkLg0KICAgICAgPC9saT4gDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+QWRkZWQgRkFRLCBhbmQgdXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPiAgIA0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC41IC0gMXN0IEp1bmUgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+Rm9ybSBjb250cm9sIGVuY29kZXMgdGhlIGZvcm0gPHR0PiJhY3Rpb24iPC90dD4gVVJMIGF0dHJpYnV0ZSB1c2luZw0KICAgICAgICAgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2phdmEuc3VuLmNvbS9wcm9kdWN0cy9zZXJ2bGV0LzIuMy9qYXZhZG9jL2phdmF4L3NlcnZsZXQvaHR0cC9IdHRwU2VydmxldFJlc3BvbnNlLmh0bWwjZW5jb2RlVVJMKGphdmEubGFuZy5TdHJpbmcpIj5lbmNvZGVVUkwoU3RyaW5nKTwvYT4NCiAgICAgICAgIHRvIGVuc3VyZSBzZXNzaW9uIElEIGlzIHNldC4NCiAgICAgIDwvbGk+IA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIG9wdGlvbmFsIEZvcm0gdmFsaWRhdGlvbi4gQSANCiAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI3ZhbGlkYXRlIj52YWxpZGF0ZTwvYT4NCiAgICAgICAgIHByb3BlcnR5IGhhcyBiZWVkIGFkZGVkIHRvIEZvcm0gYW5kIGEgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI3ZhbGlkYXRlKCkiPnZhbGlkYXRlKCk8L2E+DQogICAgICAgICBtZXRob2QgdG8gRmllbGQuIEZpZWxkIHN1YmNsYXNzZXMgaGF2ZSBiZWVuIG1vZGlmaWVkIHRvIHN1cHBvcnQgb3B0aW9uYWwNCiAgICAgICAgIHZhbGlkYXRpb24uICBTZWUgdGhlIENsaWNrIEV4YW1wbGVzIEZvcm0gUHJvcGVydGllcyBwYWdlIGZvciBhIGRlbW9uc3RyYXRpb24uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZCBTZXNzaW9uIE9iamVjdCB1dGlsaXR5IG1ldGhvZHMgdG8gQ29udGV4dCwgc2VlIA0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI2dldFNlc3Npb25PYmplY3QoamF2YS5sYW5nLkNsYXNzKSI+Z2V0U2Vzc2lvbk9iamVjdDwvYT4uDQogICAgICA8L2xpPiANCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZCBlcnJvciBtZXNzYWdlIGJsb2NrIGhvcml6b250YWwgYWxpZ25tZW50IHByb3BlcnR5DQogICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNlcnJvcnNBbGlnbiI+ZXJyb3JzQWxpZ248L2E+DQogICAgICAgICB0byBGb3JtLg0KICAgICAgPC9saT4gIA0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4gICANCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuNCAtIE1heSAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5JbXBsZW1lbnRlZCA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMwNi5odG1sI3BhZ2UtdGVtcGxhdGluZyI+UGFnZSBUZW1wbGF0aW5nPC9hPg0KICAgICAgICAgY2FwYWJpbGl0eS4gRW5hYmxpbmcgeW91IHRvIGNyZWF0ZSBhIHN0YW5kYXJkaXplZCBsb29rIGFuZCBmZWVsIGZvciB5b3VyIHdlYiANCiAgICAgICAgIGFwcGxpY2F0aW9uIGFuZCBncmVhdGx5IHJlZHVjaW5nIHRoZSBhbW91bnQgb2YgSFRNTCB5b3UgbmVlZCB0byBtYWludGFpbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+SW1wcm92ZWQgRXJyb3IgaGFuZGxpbmcuIEFwcGxpY2F0aW9uIGV4Y2VwdGlvbnMgcmVuZGVyDQogICAgICAgICBlcnJvciBzb3VyY2UgbGluZSB3aGVuIEphdmEgc291cmNlIGF2YWlsYWJsZS4gRm9yIGV4YW1wbGUgYQ0KICAgICAgICAgPGEgaHJlZj0iZXJyb3ItbnBlLmh0bWwiPk51bGxQb2ludGVyRXhjZXB0aW9uPC9hPi4gICAgDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkludGVncmF0ZWQgdGhlIERIVE1MIENhbGVuZGFyIHdpZGdldCBieSA8YSBocmVmPSJodHRwOi8vd3d3LmR5bmFyY2guY29tLyI+RHluYS5jb208L2E+DQogICAgICAgICBpbnRvIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9EYXRlRmllbGQuaHRtbCI+RGF0ZUZpZWxkPC9hPiBjb250cm9sLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZCBGb3JtIGFuZCBGaWVsZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwjcmVhZG9ubHkiPnJlYWRvbmx5PC9hPiANCiAgICAgICAgIHByb3BlcnR5LiBNb2RpZmllZCBGaWVsZCBzdWJjbGFzc2VzIHRvIHJlbmRlciB0aGVpciBIVE1MIHJlYWRvbmx5IGF0dHJpYnV0ZS4gSWYgdGhlIEZvcm0gaXMgc2V0IHRvDQogICAgICAgICByZWFkb25seSBhbGwgaXRzIGZpZWxkcyB3aWxsIGFsc28gYmUgcmVhZG9ubHkuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIENvbnRyb2wgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI2dldElkKCkiPmdldElkKCk8L2E+IA0KICAgICAgICAgbWV0aG9kLiBNb2RpZmllZCBjb250cm9sIGNsYXNzZXMgdG8gcmVuZGVyIHRoZWlyIEhUTUwgaWQgYXR0cmlidXRlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZCBGb3JtIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2NvbHVtbnMiPmNvbHVtbnM8L2E+IA0KICAgICAgICAgcHJvcGVydHkgdG8gcmVuZGVyIGZvcm1zIGluIG11bHRpIGNvbHVtbiB0YWJsZSBsYXlvdXQuICAgIA0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZCBwYWdlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNwYXRoIj5wYXRoPC9hPiANCiAgICAgICAgIHByb3BlcnR5IHRvIFZlbG9jaXR5IGNvbnRleHQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkZpeGVkIFNvdXJjZVZpZXdlciBtaXNzaW5nIHJlc291cmNlIGJ1ZyB3aGljaCBvY2N1cnJlZCBvbiBPcmlvbiBzZXJ2ZXIuPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjMgLSBNYXJjaCAyMDA1PC9kdD4NCiAgPGRkPlByZWxpbWluYXJ5IHJlbGVhc2UgZm9yIHB1YmxpYyByZXZpZXcuDQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4yIC0gMjAwNDwvZHQ+DQogIDxkZD4NCiAgICBNYWpvciByZXdyaXRlLCByZXBsYWNpbmcgY29tbWFuZCBwYXR0ZXJuIHdpdGggUGFnZSBvcmllbnRlZCBkZXNpZ24uIENsaWNrDQogICAgYXBwbGljYXRpb24gZGVzY3JpcHRvciByYXRpb25hbGl6ZWQgYW5kIHNpbXBsaWZpZWQuDQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4xIC0gMjAwMzwvZHQ+DQogIDxkZD5Jbml0aWFsIENsaWNrIHZlcnNpb24uIFVzZXMgQ29tbWFuZCBwYXR0ZXJuIGFuZCBWZWxvY2l0eSB0ZW1wbGF0aW5nIGVuZ2luZS4NCiAgICA8cC8+DQogICAgQ2xpY2sgdGVhbSBibG9nZ2luZyBhcHBsaWNhdGlvbiBkZXBsb3llZCBvbiBUb21jYXQgNC4wIGFuZCBPcmFjbGUgOWkgYXBwbGljYXRpb24gc2VydmVycy4NCiAgPC9kZD4NCiAgPHAvPg0KPC9kbD4NCg0KPCEtLSBGT09URVIgLS0+DQo8ZGl2IGlkPSJmb290ZXIiPg0KICAgIDxoci8+DQogICAgPHA+DQogICAgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9J2h0dHA6Ly93d3cuYXBhY2hlLm9yZycgdGl0bGU9J0FwYWNoZSBTb2Z0d2FyZSBGb3VuZGF0aW9uJz4NCiAgICAgICAgPGltZyBpZD0iYXNmLWxvZ28iIHNyYz0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2ltYWdlcy9hc2YtbG9nby5naWYiIGFsdD0iQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24iLz4NCiAgICA8L2E+DQogICAgQ29weXJpZ2h0ICZjb3B5OyAyMDAxLTIwMTAgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24uIEFwYWNoZSBDbGljaywNCiAgICBDbGljaywgQXBhY2hlLCB0aGUgQXBhY2hlIGZlYXRoZXIgbG9nbywgYW5kIHRoZSBBcGFjaGUgQ2xpY2sgcHJvamVjdCBsb2dvIGFyZQ0KICAgIHRyYWRlbWFya3Mgb2YgVGhlIEFwYWNoZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLg0KICAgIDxhIGhyZWY9Imh0dHA6Ly9jYXllbm5lLmFwYWNoZS5vcmcvcHJpdmFjeS1wb2xpY3kuaHRtbCI+UHJpdmFjeSBwb2xpY3kuPC9hPg0KICAgIDwvcD4NCjwvZGl2Pg0KDQo8L2JvZHk+DQo8L2h0bWw+DQoNCg==