PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiINCiAiaHR0cDovL3d3dy53My5vcmcvVFIvaHRtbDQvbG9vc2UuZHRkIj4NCjwhLS0NCiAgIExpY2Vuc2VkIHRvIHRoZSBBcGFjaGUgU29mdHdhcmUgRm91bmRhdGlvbiAoQVNGKSB1bmRlciBvbmUNCiAgIG9yIG1vcmUgY29udHJpYnV0b3IgbGljZW5zZSBhZ3JlZW1lbnRzLiAgU2VlIHRoZSBOT1RJQ0UgZmlsZQ0KICAgZGlzdHJpYnV0ZWQgd2l0aCB0aGlzIHdvcmsgZm9yIGFkZGl0aW9uYWwgaW5mb3JtYXRpb24NCiAgIHJlZ2FyZGluZyBjb3B5cmlnaHQgb3duZXJzaGlwLiAgVGhlIEFTRiBsaWNlbnNlcyB0aGlzIGZpbGUNCiAgIHRvIHlvdSB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUNCiAgICJMaWNlbnNlIik7IHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2UNCiAgIHdpdGggdGhlIExpY2Vuc2UuICBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXQNCg0KICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjANCg0KICAgVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLA0KICAgc29mdHdhcmUgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4NCiAgICJBUyBJUyIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWQ0KICAgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4gIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlDQogICBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kIGxpbWl0YXRpb25zDQogICB1bmRlciB0aGUgTGljZW5zZS4NCi0tPg0KPGh0bWw+DQo8aGVhZD4NCiA8IS0tIHNhdmVkIGZyb20gdXJsPSgwMDE0KWFib3V0OmludGVybmV0IC0tPg0KIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PWlzby04ODU5LTEiLz4NCiA8bWV0YSBuYW1lPSJBdXRob3IiIGNvbnRlbnQ9Ik1hbGNvbG0gRWRnYXIiLz4NCiA8bWV0YSBuYW1lPSJkZXNjcmlwdGlvbiIgbGFuZz0iZW4iIGNvbnRlbnQ9IkFwYWNoZSBDbGljayBKYXZhIHdlYiBhcHBsaWNhdGlvbiBmcmFtZXdvcmsiLz4NCiA8bWV0YSBuYW1lPSJrZXl3b3JkcyIgbGFuZz0iZW4iIGNvbnRlbnQ9IkFwYWNoZSBDbGljaywgQ2xpY2ssIENsaWNrIEZyYW1ld29yaywgSmF2YSwgSkVFLCBKMkVFLCB3ZWIgYXBwbGljYXRpb24gZnJhbWV3b3JrLCBvcGVuIHNvdXJjZSIvPg0KIDx0aXRsZT5BcGFjaGUgQ2xpY2s8L3RpdGxlPg0KIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgdHlwZT0idGV4dC9jc3MiIGhyZWY9Ii4uL2hlbHAuY3NzIi8+DQogPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiB0eXBlPSJ0ZXh0L2NzcyIgaHJlZj0iLi4vc3ludGF4LWhpZ2hsaWdodGVyLmNzcyIvPg0KIDxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+DQogIGRsIHsNCiAgICBtYXJnaW4tbGVmdDogMmVtOw0KICB9DQogIGR0IHsNCiAgICBmb250LXdlaWdodDogNzAwOw0KICAgIG1hcmdpbi10b3A6IDEuNWVtOw0KICAgIG1hcmdpbi1ib3R0b206IDAuNWVtOw0KICB9DQogIC5jaGFuZ2Ugew0KICAgIG1hcmdpbi1ib3R0b206IDAuNzVlbTsNCiAgfQ0KICAudXBncmFkZSB7DQogICAgbWFyZ2luLWJvdHRvbTogMC43NWVtOw0KICAgIG1hcmdpbi10b3A6IDAuNzVlbTsNCiAgfQ0KICAucmVsZWFzZS1oZWFkZXIgew0KICAgIGJhY2tncm91bmQ6ICNFRkVGRjc7DQogICAgcGFkZGluZzogNHB4Ow0KICAgIHBhZGRpbmctbGVmdDogOHB4Ow0KICAgIGJvcmRlcjogMXB4IHNvbGlkICM5OUE0REY7DQogIH0NCiAgcHJlIHsNCiAgICBwYWRkaW5nOiA0cHg7DQogICAgYm9yZGVyOiAxcHggc29saWQgIzk5QTRERjsNCiAgfQ0KICBhIHsNCiAgCXRleHQtZGVjb3JhdGlvbjogbm9uZTsNCiAgfQ0KIDwvc3R5bGU+DQo8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSIuLi9zeW50YXgtaGlnaGxpZ2h0ZXIuanMiPjwvc2NyaXB0Pg0KPC9oZWFkPg0KPCEtLUFjdGl2YXRlIHN5bnRheCBoaWdobGlnaHRpbmctLT4NCiA8Ym9keSBvbmxvYWQ9InByZXR0eVByaW50KCk7Ij4NCg0KPGgxPlJvYWQgTWFwIGFuZCBDaGFuZ2VzPC9oMT4NCjxoND5BIEpJUkEgYmFzZWQgPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEsjc2VsZWN0ZWRUYWI9Y29tLmF0bGFzc2lhbi5qaXJhLnBsdWdpbi5zeXN0ZW0ucHJvamVjdCUzQXJvYWRtYXAtcGFuZWwiPlJvYWRNYXA8L2E+IHdpdGggdGhlIG5leHQgcGxhbm5lZCBpbXByb3ZlbWVudHMuPC9oND4NCjxoND48c3Ryb25nPkNoYW5nZXM8L3N0cm9uZz4gKGFsbCBzaW5jZSB2MC4xKSA6PC9oND4NCjxkbD4NCiAgPGR0PjxhIG5hbWU9IjIuNC4wIj48L2E+DQogICAgICA8ZGl2IGNsYXNzPSJyZWxlYXNlLWhlYWRlciI+TGF0ZXN0IFN0YWJsZSBSZWxlYXNlIC0gVmVyc2lvbiAyLjQuMCAtID8/IE5vdmVtYmVyIDIwMTM8L2Rpdj4NCiAgPC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIDxiPklNUE9SVEFOVDo8L2I+IGJlIHN1cmUgdG8gcmVhZCB0aGUgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjMi40LjAiPnVwZ3JhZGUgcGF0aDwvYT4NCiAgICAgIHdoZW4gdXBncmFkaW5nIGZyb20gcHJldmlvdXMgcmVsZWFzZXMuDQogICAgPC9kaXY+DQogICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgICA8Yj5OZXcgZmVhdHVyZXMgYW5kIGlzc3VlcyByZXNvbHZlZDo8L2I+DQogICAgICA8L2Rpdj4NCiAgICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIFVwZGF0ZSBzb21lIG9mIHRoZSBKQVJzIGRlcGVuZGVuY2llcyB0byB0aGUgbGF0ZXN0IHZlcnNpb24gc3RpbGwgY29tcGF0aWJsZSB3aXRoIEphdmEgNToNCiAgICAgICAgICAgICAgbG9nNGotMS4yLjE3LCBjb21tb25zLWlvLTIuMiwganVuaXQtNC4xMSwgY29tbW9ucy1maWxldXBsb2FkLTEuMywgY29tbW9ucy1jb2RlYy0xLjYsDQogICAgICAgICAgICAgIG12ZWwtMi4xLjcuRmluYWwNCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgQWRkZWQgUGFnZSBtZXRob2QgZ2V0Q2hhcmFjdGVyRW5jb2RpbmcuIFRoZSByZXNwb25zZSBjaGFyYWN0ZXIgZW5jb2RpbmcNCiAgICAgICAgICAgICAgY2FuIGJlIG92ZXJyaWRkZW4gdGhyb3VnaCB0aGlzIG1ldGhvZC4gZ2V0Q2hhcmFjdGVyRW5jb2Rpbmcgc2hvdWxkIGJlDQogICAgICAgICAgICAgIHVzZWQgaW5zdGVhZCBvZiByZXR1cm5pbmcgdGhlIDx0dD5jaGFyc2V0PC90dD4gdGhyb3VnaCB0aGUgZ2V0Q29udGVudFR5cGUNCiAgICAgICAgICAgICAgbWV0aG9kDQogICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03NjQiPkNMSy03NjQ8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICAgQWRkZWQgUHJvcGVydHlTZXJ2aWNlIGludGVyZmFjZSB3aXRoIE9HTkwgYW5kIE1WRUwgcHJvcGVydHkgc2VydmljZSBpbXBsZW1lbnRhdGlvbnMuDQogICAgICAgICAgICAgIFRoZSBkZWZhdWx0IHByb3BlcnR5IHNlcnZpY2UgaXMgT0dOTFByb3BlcnR5U2VydmljZSBwcmluY2lwYWxseSBmb3INCiAgICAgICAgICAgICAgYmFja3dhcmQgY29tcGF0aWJpbGl0eQ0KICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzA2Ij5DTEstMzA2PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEFkZGVkIFNlc3Npb25NYXAgbWV0aG9kcyBnZXRDcmVhdGlvblRpbWUsIGdldElkLCBnZXRMYXN0QWNjZXNzZWRUaW1lIGFuZCBnZXRNYXhJbmFjdGl2ZUludGVydmFsDQogICAgICAgICAgICAgIHRvIGV4cG9zZSB1bmRlcmx5aW5nIHJlYWQgb25seSBIdHRwU2Vzc2lvbiBwcm9wZXJ0aWVzDQogICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03NzMiPkNMSy03NzM8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgQWRkZWQgVVJMIHJlcXVlc3QgcGFyYW1zIG9wdGlvbnMgdG8gdGhlIFBhZ2VTdWJtaXQgY2xhc3MNCiAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc3OSI+Q0xLLTc3OTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAJCSAgPGxpPg0KCQkJICBBZGRlZCBzdXBwb3J0IHVzaW5nIENsaWNrIGFzIGEgSkJvc3MgNyBtb2R1bGUNCgkJICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc4OCI+Q0xLLTc4MzwvYT5dLg0KICAgCQkgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBSZW1vdmVkIEF1dG9Db21wbGV0ZVRleHRGaWVsZCBkZXBlbmRlbmN5IG9uIFBhZ2UuIFRoZSBBamF4IGNhbGxiYWNrDQogICAgICAgICAgICAgIFVSTCBpcyBpbnN0ZWFkIGxvb2tlZCB1cCBmcm9tIHRoZSByZXF1ZXN0IGl0c2VsZi4gVGhpcyBjaGFuZ2UgcmVtb3Zlcw0KICAgICAgICAgICAgICB0aGUgcmVzdHJpY3Rpb24gdGhhdCBBdXRvQ29tcGxldGVUZXh0RmllbGQgbXVzdCBiZSBhdHRhY2hlZCB0byB0aGUNCiAgICAgICAgICAgICAgUGFnZQ0KICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzYxIj5DTEstNzYxPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIEF1dG9Db21wbGV0ZVRleHRGaWVsZCB0byBub3Qgc2VuZCBkdXBsaWNhdGUgY29udGVudCB0eXBlIGluDQogICAgICAgICAgICAgIHJlc3BvbnNlDQogICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03NTciPkNMSy03NTc8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgcGFnZSBhY3Rpb25zIHRvIHNob3cgZXJyb3IgcGFnZSBpZiBlcnJvciBvY2N1cnMuDQogICAgICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBUaW0gQ2hyaXN0ZW5zZW4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc2NyI+Q0xLLTc2NzwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCBBdXRvQ29tcGxldGVUZXh0RmllbGQgdG8gYWRkIGV4dHJhIHBhcmFtZXRlcnMgY29ycmVjdGx5Lg0KICAgICAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSm9zZSBMdWlzIFbhenF1ZXogR29ueuFsZXoNCiAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc1OSI+Q0xLLTc1OTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCBFcnJvclJlcG9ydCB0byBlc2NhcGUgdGhlIHJlcXVlc3QgcXVlcnkgc3RyaW5nLg0KICAgICAgICAgICAgICBUaGlzIGlzc3VlIGhhcyBiZWVuIHJhaXNlZCBieSBUc3V5b3NoaSBZYW1hbW90bw0KICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzYyIj5DTEstNzYyPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIFVwZ3JhZGVkIHRvIFNlcnZsZXQgQVBJIDIuNA0KICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzYzIj5DTEstNzYzPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgIDwvdWw+DQogIDwvZGQ+DQoNCiAgPGR0PjxkaXYgY2xhc3M9InJlbGVhc2UtaGVhZGVyIj5BcmNoaXZlczwvZGl2PjwvZHQ+DQogIDxkdD48YSBuYW1lPSIyLjMuMCI+PC9hPg0KICAgICAgPGRpdj5WZXJzaW9uIDIuMy4wIC0gMjcgTWFyY2ggMjAxMTwvZGl2Pg0KICA8L2R0Pg0KICA8ZGQ+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+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBBZGRlZCBuZXcgQ2F5ZW5uZVV0aWxzIG1ldGhvZCwgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL0NheWVubmVVdGlscy5odG1sI2FwcGx5TWV0YURhdGEob3JnLmFwYWNoZS5jbGljay5jb250cm9sLkZvcm0sIGphdmEubGFuZy5DbGFzcykiPmFwcGx5TWV0YURhdGEoRm9ybSwgQ2xhc3MpPC9hPiwNCiAgICAgICAgICAgICAgZm9yIGFkZGluZyB2YWxpZGF0aW9uIG1ldGFkYXRhIHN1Y2ggYXMgcmVxdWlyZWQgYW5kIG1heGxlbmd0aA0KICAgICAgICAgICAgICB0byBmb3JtIGZpZWxkcyBmb3IgYSBnaXZlbiBEYXRhT2JqZWN0IHR5cGUNCiAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc1NiI+Q0xLLTc1NjwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBtdWx0aXBsZSBUYWJiZWRQYW5lbHMgb24gYSBwYWdlLiBUbyBwcm9ncmFtbWF0aWNhbGx5DQogICAgICAgICAgICAgIGFjdGl2YXRlIGEgc3BlY2lmaWMgVGFiYmVkUGFuZWwgdXNlIHRoZSA8dHQ+dGFiUGFuZWxJbmRleC0mbHQ7cGFuZWwtbmFtZSZndDs8L3R0Pg0KICAgICAgICAgICAgICByZXF1ZXN0IHBhcmFtZXRlciwgZm9yIGV4YW1wbGUgPHR0PnRhYlBhbmVsSW5kZXgtbXlUYWJiZWRQYW5lbDwvdHQ+DQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzUzIj5DTEstNzUzPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEltcHJvdmUgZmllbGRzIHRvIG9ubHkgYmUgcHJvY2Vzc2VkIGlmIHRoZXkgaGF2ZSBhbiBpbmNvbWluZyByZXF1ZXN0DQogICAgICAgICAgICAgIHBhcmFtZXRlci4gVGhpcyBpbXByb3ZlbWVudCBzdHJlYW1saW5lcyBkeW5hbWljIGZvcm1zIHNpbmNlIGZpZWxkcw0KICAgICAgICAgICAgICBhZGRlZCBhdCBydW50aW1lIGR1cmluZyBzIFBPU1QgcmVxdWVzdCB3b24ndCBiaW5kIHRoZWlyIHZhbHVlcyBhbmQNCiAgICAgICAgICAgICAgd29uJ3QgYmUgdmFsaWRhdGVkIGZvciB0aGF0IHJlcXVlc3QuIEluIHN1YnNlcXVlbnQgcmVxdWVzdHMgdGhlIEZpZWxkDQogICAgICAgICAgICAgIHdpbGwgaGF2ZSBhbiBpbmNvbWluZyBwYXJhbWV0ZXIgYW5kIHNvIHdpbGwgaGF2ZSBpdCdzIHZhbHVlIGJvdW5kIGFuZA0KICAgICAgICAgICAgICB2YWxpZGF0ZWQuIEFub3RoZXIgYWR2YW50YWdlIGlzIHRoYXQgZHluYW1pY2FsbHkgYWRkZWQgRmllbGRzIHdvbid0DQogICAgICAgICAgICAgIGhhdmUgdGhlaXIgZGVmYXVsdCB2YWx1ZSBvdmVycmlkZGVuIGluIHRoZSBQT1NUIHJlcXVlc3QgdGhleSB3ZXJlIGFkZGVkIGluLg0KICAgICAgICAgICAgICBUaGlzIGlzc3VlIGhhcyBiZWVuIHJhaXNlZCBieSBOaXJtYWwgU29sYW5raQ0KICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MjIiPkNMSy03MjI8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgIEFkZGVkIGF1dG9tYXBwaW5nIHN1cHBvcnQgZm9yIEdBRSB3aXRoIGEgY2F2ZWF0IHRoYXQgcGFnZSB0ZW1wbGF0ZXMNCiAgICAgICAgICAgIG11c3QgYmUgcGxhY2VkIHVuZGVyIHRoZSBmb2xkZXJzIDx0dD5wYWdlPC90dD4gb3IgPHR0PnBhZ2VzPC90dD4uDQogICAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgS2UgU3VuDQogICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYzOSI+Q0xLLTYzOTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svc2VydmljZS9NZXNzYWdlc01hcFNlcnZpY2UuaHRtbCI+TWVzc2FnZXNNYXBTZXJ2aWNlPC9hPg0KICAgICAgICAgICAgaW50ZXJmYWNlIHRvIHN1cHBvcnQgcGx1Z2dhYmxlIG1lc3NhZ2VzIG1hcCBpbXBsZW1lbnRhdGlvbnMNCiAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjU1Ij5DTEstNjU1PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICBJbXByb3ZlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL01lc3NhZ2VzTWFwLmh0bWwiPk1lc3NhZ2VzTWFwPC9hPg0KICAgICAgICAgICAgdG8gYmUgZXh0ZW5kYWJsZSBhbmQgY3VzdG9taXphYmxlDQogICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcyOCI+Q0xLLTcyODwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgbG9hZGluZyA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvRGF0ZUZpZWxkLmh0bWwiPkRhdGVGaWVsZDwvYT4NCiAgICAgICAgICAgIHRyYW5zbGF0aW9ucyBmb3IgbW9udGggYW5kIGRheSBuYW1lcyBmcm9tIHRoZSBKREsuDQogICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY1MCI+Q0xLLTY1MDwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBNZW51cyB0aGF0IGRvIG5vdCBoYXZlIDx0dD5yb2xlczwvdHQ+IGRlZmluZWQuDQogICAgICAgICAgICAgIElmIG5vIHJvbGVzIGFyZSBkZWZpbmVkLA0KICAgICAgICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTWVudS5odG1sI2lzVXNlckluUm9sZXMoKSI+SXNVc2VySW5Sb2xlczwvYT4NCiAgICAgICAgICAgICAgcGFzc2VzIGEgPHR0Pm51bGw8L3R0PiBhcmd1bWVudCB0bw0KICAgICAgICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NlY3VyaXR5L0FjY2Vzc0NvbnRyb2xsZXIuaHRtbCNoYXNBY2Nlc3MoamF2YXguc2VydmxldC5odHRwLkh0dHBTZXJ2bGV0UmVxdWVzdCwgamF2YS5sYW5nLlN0cmluZykiPmhhc0FjY2VzczwvYT4NCiAgICAgICAgICAgICAgdG8gZGV0ZXJtaW5lIHdoZXRoZXIgYWNjZXNzIGlzIHBlcm1pdHRlZCB0byBtZW51cyB3aXRob3V0IHJvbGVzDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzI0Ij5DTEstNzI0PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIFBvbGlzaCBsYW5ndWFnZSBzdXBwb3J0Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFRvbWFzeiBCYW5kdXJhDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzM5Ij43Mzk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBDaGFuZ2VkIEFic3RyYWN0Q29udHJvbCBub3QgdG8gcmVuZGVyIHRoZSA8dHQ+bmFtZTwvdHQ+DQogICAgICAgICAgICAgIGF0dHJpYnV0ZSBzaW5jZSBpdCBpcyBvbmx5IHVzZWQgZm9yIEZpZWxkIGNvbnRyb2xzDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjk5Ij5DTEstNjk5PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEltcHJvdmVkIFRhYmxlIGFuZCBTZWxlY3QgdG8gcmV0cmlldmUgZGF0YSBmcm9tIHRoZWlyIERhdGFQcm92aWRlcnMNCiAgICAgICAgICAgICAgZHVyaW5nIHRoZSBvblJlbmRlciBldmVudC4gVGhpcyBjaGFuZ2UgYWxsb3dzIGV4Y2VwdGlvbnMgdGhyb3duDQogICAgICAgICAgICAgIGJ5IERhdGFQcm92aWRlcnMgdG8gYmUgaGFuZGxlZCBieSB0aGUgRXJyb3JQYWdlDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjg0Ij5DTEstNjg0PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEltcHJvdmVkIERhdGVGaWVsZCB0byBsb2FkIHRoZSA8dHQ+ZGF0ZS1mb3JtYXQtcGF0dGVybjwvdHQ+IG9uIGRlbWFuZC4NCiAgICAgICAgICAgICAgVGhpcyBjaGFuZ2UgYWxsb3dzIG9uZSB0byBvdmVycmlkZSB0aGUgZGVmYXVsdCA8dHQ+ZGF0ZS1mb3JtYXQtcGF0dGVybjwvdHQ+DQogICAgICAgICAgICAgIGZyb20gdGhlIHBhZ2UgcHJvcGVydGllcyBmaWxlOiA8dHQ+Y2xpY2stcGFnZS5wcm9wZXJ0aWVzPC90dD4uDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzA1Ij5DTEstNzA1PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIGFic29sdXRlIHBhZ2UgY2xhc3NuYW1lcyB3aGVuIGNvbmZpZ3VyaW5nIHBhZ2VzDQogICAgICAgICAgICAgIGluIDx0dD5jbGljay54bWw8L3R0Pi4gQWJzb2x1dGUgY2xhc3NuYW1lcyBhaWRzIHdpdGggSURFIGhvdC1saW5raW5nDQogICAgICAgICAgICAgIGFuZCBpcyBsZXNzIGNvbmZ1c2luZyB0byB1c2UuDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzA0Ij5DTEstNzA0PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEFkZGVkIGEgcmVuZGVySWQgcHJvcGVydHkgdG8gUmVzb3VyY2VFbGVtZW50IHRvIGV4Y2x1ZGUgdGhlIElEIGF0dHJpYnV0ZSBmcm9tIHJlbmRlcmluZw0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY5NSI+Q0xLLTY5NTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBJbXByb3ZlZCBDb3VudHJ5U2VsZWN0IHRvIGluY2x1ZGUgbW9yZSBjb3VudHJpZXMgYnkgdXNpbmcgTG9jYWxlLmdldElTT0NvdW50cmllcygpLg0KICAgICAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IExvcmVuem8gU2ltaW9uYXRvDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzQwIj5DTEstNzQwPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIENvbnRyb2wgSURzIHRvIHJlbmRlciB1bmRlcnNjb3JlcyBpbnN0ZWFkIG9mIHBlcmlvZHMNCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03NDciPkNMSy03NDc8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgVGFiYmVkRm9ybSBhbmQgQ2F5ZW5uZVRhYmJlZEZvcm0gSmF2YVNjcmlwdCB2YWxpZGF0aW9uLiBUaGlzDQogICAgICAgICAgICAgIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFRvbWFzeiBCYW5kdXJhDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzM1Ij5DTEstNzM1PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIGVzY2FwaW5nIG9mIGNvbnRyb2wgdmFsdWVzIGFuZCBhdHRyaWJ1dGVzIHRvIGJlIFhNTCBmcmllbmRseQ0KICAgICAgICAgICAgICBpbiBvcmRlciB0byBzdXBwb3J0IEFqYXggcmVxdWVzdHMuIFByZXZpb3VzbHkgYWxsIEhUTUwgY2hhcmFjdGVycyB3YXMgZXNjYXBlZCwNCiAgICAgICAgICAgICAgbm93IG9ubHkgdGhlIGZvbGxvd2luZyBjaGFyYWN0ZXJzIGFyZSBlc2NhcGVkOiAmbHQ7LCAmZ3Q7LCAmcXVvdDssICYjMDM5OywgJmFtcDsNCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NzQiPkNMSy02NzQ8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgQWRkZWQgbWV0aG9kLCBDbGlja1V0aWxzLmVzY2FwZShTdHJpbmcpLCB0byBlc2NhcGUgWE1MIGNoYXJhY3RlcnMuDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEltcHJvdmVkIENsaWNrVXRpbHMuZW5jb2RlVXJsIHRvIGRlZmF1bHQgdG8gIlVURi04IiBpZiBubyByZXF1ZXN0DQogICAgICAgICAgICAgIGNoYXJhY3RlciBlbmNvZGluZyBpcyBhdmFpbGFibGUNCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MjAiPkNMSy03MjA8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgSW1wcm92ZWQgcGFnZSBoZWFkZXIgc3VwcG9ydCBhbGxvd2luZyBoZWFkZXJzIHRvIGJlIHNldCBmcm9tIHBhZ2UgY29uc3RydWN0b3INCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MTEiPkNMSy03MTE8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgVGFibGUgY29udHJvbExpbmsgd2hpY2ggZGlkIG5vdCBrZWVwIGEgcmVmZXJlbmNlIHRvIGl0cyBwYXJlbnQNCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02ODYiPkNMSy02ODY8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgQ29uY3VycmVudE1vZGlmaWNhdGlvbkV4Y2VwdGlvbiB3aGVuIHJlbmRlcmluZyBjYWNoZWQgTWVudXMNCiAgICAgICAgICAgICAgZnJvbSBtdWx0aXBsZSB0aHJlYWRzDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzEyIj5DTEstNzEyPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIHJhY2UgY29uZGl0aW9uIHdoaWxlIGluaXRpYWxpemluZyBjYWNoZWQgbWVudXMNCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MTMiPkNMSy03MTM8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgbWVudSBub3QgcmVuZGVyaW5nIHNlcGFyYXRvcg0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY4MSI+Q0xLLTY4MTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCBTdWJtaXRMaW5rIHRvIHVzZSBGb3JtIGlkIGluc3RlYWQgb2YgRm9ybSBuYW1lDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzAxIj5DTEstNzAxPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIEZvcm0gdmFsaWRhdGlvbiB0byBhZGQgYW5kIHJlbW92ZSBhbiA8dHQ+ZXJyb3I8L3R0PiBjbGFzcw0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcwMCI+Q0xLLTcwMDwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCBpc3N1ZSB3aGVyZSBDb250ZXh0LmNyZWF0ZVBhZ2UgY291bGQgbGVhZCB0byBkdXBsaWNhdGUgcGFnZS10by1jbGFzcw0KICAgICAgICAgICAgICBtYXBwaW5ncy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFuZHJleSBSeWJpbiBhbmQgZml4ZWQgYnkgTWQuIEphaGlkIFNob2hlbA0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYyNSI+Q0xLLTYyNTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCBBdXRvQ29tcGxldGVUZXh0RmllbGQgbm90IHRvIGJlIGFkZGVkIHRvIHBhcmVudCBQYWdlDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzA3Ij5DTEstNzA3PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICBGaXhlZCBhIHBvdGVudGlhbCBtZW1vcnkgbGVhayB3aGVuIHVuZGVwbG95aW5nIGEgY2xpY2sgYXBwbGljYXRpb24uDQogICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcwNiI+Q0xLLTcwNjwvYT5dLg0KICAgICAgICAgPC9saT4NCiAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgaXNzdWUgd2hlcmUgc2V0dGluZyA8dHQ+YXV0b2JpbmRpbmc9ImRlZmF1bHQiPC90dD4gdGhyb3dzIGV4Y2VwdGlvbi4NCiAgICAgICAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFRzYXkgWWF3IEhhbm4NCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03MTQiPkNMSy03MTQ8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgRml4ZWQgU2VsZWN0IHRvIHNldCBhbiBpbml0aWFsIHZhbHVlIHdoZW4gcG9wdWxhdGVkIHRocm91Z2ggYQ0KICAgICAgICAgICAgICBEYXRhUHJvdmlkZXIuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgU2FuZGVyIHZhbiBHcmlla2VuDQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzQ1Ij5DTEstNzQ1PC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQpGaXhlZCB0YWJsZSBoZWFkZXJzIHRoYXQgdXNlZCBpbmNvcnJlY3QgdGl0bGUgYXR0cmlidXRlIHdoZW4gdGFibGUgaXMgc29ydGFibGUuDQogICAgICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBQYXRyaWNrIFRhbGJvdA0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI0MSI+Q0xLLTI0MTwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgICAgICBGaXhlZCBDYXllbm5lVGVtcGxhdGUgZ2VuZXJpY3MgdG8gYWxpZ24gd2l0aCBDYXllbm5lIERhdGFDb250ZXh0DQogICAgICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzUwIj5DTEstNzUwPC9hPl0uDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIEZpeGVkIHJlYWRvbmx5IENoZWNrTGlzdCB0byB1c2UgPHR0PmRpc2FibGVkPC90dD4gYXR0cmlidXRlLA0KICAgICAgICAgICAgICBzYW1lIGFzIENoZWNrYm94IGRvZXMgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03NTEiPkNMSy03NTE8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgUmVtb3ZlZCB0aGUgPHR0PiNGSVhFRDwvdHQ+IGF0dHJpYnV0ZXMgZnJvbSB0aGUgPHR0PmNsaWNrLmR0ZDwvdHQ+DQogICAgICAgICAgICAgIHdoaWNoIGNhdXNlZCB4bWwgdmFsaWRhdGlvbiBlcnJvcnMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSeWFuIEhvbG1lcw0KICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTcxNyI+Q0xLLTcxNzwvYT5dLg0KICAgICAgICAgIDwvbGk+DQogICAgICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIFVwZGF0ZWQgVmVsb2NpdHkgbGlicmFyeSB0byB2ZXJzaW9uIDEuNyBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTc0OCI+Q0xLLTc0ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIFVwZGF0ZSB0byB0aGUgbGF0ZXN0IHZlcnNpb24gZm9yIHNvbWUgb2YgdGhlIEpBUnMgZGVwZW5kZW5jaWVzOiBsb2c0ai0xLjIuMTYsIGZyZWVtYXJrZXItMi4zLjE2LA0KICAgICAgICAgICAgICBjb21tb25zLWNvZGVjLTEuNCwgYW5kIGNvbW1vbnMtbGFuZy0yLjUsIGNvbW1vbnMtaW8tMi4wLjEuDQogICAgICAgICAgPC9saT4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgICAgIFVwZGF0ZSB0byBWZWxvY2l0eSBUb29scyAyLjAgV2ViYXBwUmVzb3VyY2VMb2FkZXINCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02OTMiPkNMSy02OTM8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgUmVwbGFjZSBFRFUub3N3ZWdvLmNzLmRsLnV0aWwuY29uY3VycmVudC5Db25jdXJyZW50UmVhZGVySGFzaE1hcCB3aXRoIGphdmEudXRpbC5jb25jdXJyZW50LkNvbmN1cnJlbnRIYXNoTWFwLg0KICAgICAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEhlbnJ5IFNhcHV0cmENCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MzYiPkNMSy02MzY8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICAgICAgUmVtb3ZlZCBvZ25sLk9nbmxPcHMgZGVwZW5kZW5jeS4NCiAgICAgICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02OTQiPkNMSy02OTQ8L2E+XS4NCiAgICAgICAgICA8L2xpPg0KICAgICAgPC91bD4NCiAgPC9kZD4NCg0KICA8ZHQ+PGEgbmFtZT0iMi4zLjAtUkMxIj48L2E+VmVyc2lvbiAyLjMuMCBSZWxlYXNlIENhbmRpZGF0ZSAxIC0gMzAgSmFudWFyeSAyMDExPC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIFNlZSB0aGUgcmVsZWFzZSBub3RlcyBmb3IgPGEgaHJlZj0iIzIuMy4wIj4yLjMuMDwvYT4uDQogICAgPC9kaXY+DQogIDwvZGQ+DQoNCiAgPGR0PjxhIG5hbWU9IjIuMy4wLU0xIj48L2E+VmVyc2lvbiAyLjMuMC1NMSAtIDI4IE5vdmVtYmVyIDIwMTA8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgU2VlIHRoZSByZWxlYXNlIG5vdGVzIGZvciA8YSBocmVmPSIjMi4zLjAiPjIuMy4wPC9hPi4NCiAgICA8L2Rpdj4NCiAgPC9kZD4NCg0KICA8ZHQ+PGEgbmFtZT0iMi4yLjAiPjwvYT5WZXJzaW9uIDIuMi4wIC0gMjIgTWF5IDIwMTA8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgPGI+SU1QT1JUQU5UOjwvYj4gYmUgc3VyZSB0byByZWFkIHRoZSA8YSBocmVmPSJ1cGdyYWRlLXBhdGguaHRtbCMyLjIuMCI+dXBncmFkZSBwYXRoPC9hPg0KICAgICAgd2hlbiB1cGdyYWRpbmcgZnJvbSBwcmV2aW91cyByZWxlYXNlcy4NCiAgICAgIDxwLz4NCiAgICAgIEl0cyB3b3J0aCBoaWdobGlnaHRpbmcgdGhhdCBpbiB0aGlzIHJlbGVhc2Ugd2UgaGF2ZSByZW1vdmVkIHRoZSBkZXByZWNhdGVkIG1ldGhvZHMNCiAgICAgIDx0dD5QYWdlLmdldEh0bWxJbXBvcnRzPC90dD4gYW5kIDx0dD5Db250cm9sLmdldEh0bWxJbXBvcnRzPC90dD4uIFVzZXJzDQogICAgICB3aWxsIGhhdmUgdG8gbWlncmF0ZSB0aGVpciBjb2RlIHRvIHVzZSB0aGUgbmV3IDx0dD5nZXRIZWFkRWxlbWVudHM8L3R0PiBpbnN0ZWFkLg0KICAgICAgUGxlYXNlIHNlZSB0aGUgc2VjdGlvbiwgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjbWlncmF0ZS1pbXBvcnRzIj5taWdyYXRpbmcgaW1wb3J0czwvYT4sDQogICAgICBmb3IgbW9yZSBkZXRhaWxzLg0KICAgIDwvZGl2Pg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0OiAtMmVtOyBtYXJnaW4tdG9wOiAxLjVlbTsgbWFyZ2luLWJvdHRvbTogMWVtOyI+DQogICAgICA8Yj5OZXcgZXhhbXBsZXM6PC9iPg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9mb3JtL2R5bmFtaWMvZHluYW1pYy1mb3JtLmh0bSI+DQogICAgICAgIER5bmFtaWMgRm9ybTwvYT4gZGVtb25zdHJhdGVzIGhvdyB0byBkeW5hbWljYWxseSBhZGQgbmV3IEZpZWxkcyBhdCBydW50aW1lLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9mb3JtL2R5bmFtaWMvZHluYW1pYy1maWVsZC1zZXQuaHRtIj4NCiAgICAgICAgRHluYW1pYyBGaWVsZFNldDwvYT4gZGVtb25zdHJhdGVzIGhvdyB0byBkeW5hbWljYWxseSBhZGQgYSBGaWVsZFNldCBhdCBydW50aW1lLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9mb3JtL2R5bmFtaWMvZHluYW1pYy1zZWxlY3QuaHRtIj4NCiAgICAgICAgRHluYW1pYyBTZWxlY3Q8L2E+IGRlbW9uc3RyYXRlcyBob3cgdG8gZHluYW1pY2FsbHkgYWRkIGZpZWxkcyBiYXNlZCBvbiBhIFNlbGVjdCBmaWVsZCB2YWx1ZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvY29udHJvbC9kaXNhYmxlZC1kZW1vLmh0bSI+DQogICAgICAgIERpc2FibGVkIERlbW88L2E+IGRlbW9uc3RyYXRlcyB0aGUgYmVoYXZpb3Igb2YgZGlzYWJsZWQgZmllbGRzLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0OiAtMmVtOyBtYXJnaW4tdG9wOiAxLjVlbTsgbWFyZ2luLWJvdHRvbTogMWVtOyI+DQogICAgICA8Yj5OZXcgZmVhdHVyZXMgYW5kIGlzc3VlcyByZXNvbHZlZDo8L2I+DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9kYXRhcHJvdmlkZXIvRGF0YVByb3ZpZGVyLmh0bWwiPkRhdGFQcm92aWRlcjwvYT4NCiAgICAgICAgc3VwcG9ydCBmb3IgVGFibGUsIFNlbGVjdCwgUGlja0xpc3QgYW5kIENoZWNrTGlzdCBwcm92aWRpbmcNCiAgICAgICAgb24gZGVtYW5kIGxvYWRpbmcgb2YgZGF0YS4gV2l0aCBEYXRhUHJvdmlkZXJzLCB1c2VycyB3b24ndCBoYXZlIHRvIGJlDQogICAgICAgIGNvbmNlcm5lZCBhYm91dCB3aGljaCBwYWdlIGV2ZW50IChvbkluaXQgb3Igb25SZW5kZXIpIHRvIHNldCB0aGUgZGF0YSBvbg0KICAgICAgICB0aGUgY29udHJvbA0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY0MCI+Q0xLLTY0MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZGF0YXByb3ZpZGVyL1BhZ2luZ0RhdGFQcm92aWRlci5odG1sIj5QYWdpbmdEYXRhUHJvdmlkZXI8L2E+DQogICAgICAgIGludGVyZmFjZSB0byBzdXBwb3J0IGxhcmdlIHBhZ2luYXRlZCByZXN1bHQgc2V0cyBmb3IgVGFibGVzDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjQwIj5DTEstNjQwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBhIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9NZW51RmFjdG9yeS5odG1sIj5NZW51RmFjdG9yeTwvYT4NCiAgICAgICAgZm9yIGNyZWF0aW5nIGFuZCBsb2FkaW5nIE1lbnVzIGZyb20gPHR0PmNvbmZpZ3VyYXRpb248L3R0PiBmaWxlcy4gQWxsIHRoZQ0KICAgICAgICBzdGF0aWMgTWVudSBtZXRob2RzIGhhdmUgYmVlbiBkZXByZWNhdGVkIGFuZCB3aWxsIGJlIHJlbW92ZWQgaW4gYSBmdXR1cmUgcmVsZWFzZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGFuIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9NZW51RmFjdG9yeS5odG1sI2dldFJvb3RNZW51KGJvb2xlYW4pIj5vcHRpb248L2E+DQogICAgICAgIGZvciBNZW51RmFjdG9yeSB0byBub3Qgc3RhdGljYWxseSBjYWNoZSBtZW51cy4gVGhpcyBhbGxvd3MNCiAgICAgICAgZGV2ZWxvcGVycyB0byBjYWNoZSBtZW51cyBpbiBkaWZmZXJlbnQgc2NvcGVzIHN1Y2ggYXMgSHR0cFNlc3Npb24uDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDA1Ij5DTEstNDA1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBpMThuIHN1cHBvcnQgZm9yIE1lbnVzIGxvYWRlZCBmcm9tIDx0dD5tZW51LnhtbDwvdHQ+LiBUaGUgbWVudQ0KICAgICAgICBEVEQgbm93IGluY2x1ZGVzIGEgbmV3IDx0dD5uYW1lPC90dD4gYXR0cmlidXRlLiBCeSBzcGVjaWZ5aW5nDQogICAgICAgIGEgPHR0Pm5hbWU8L3R0PiBhdHRyaWJ1dGUgaW4gPHR0Pm1lbnUueG1sPC90dD4sIHRoZSBNZW51IHdpbGwgYXR0ZW1wdCB0bw0KICAgICAgICBsb2FkIGl0cyA8dHQ+bGFiZWw8L3R0PiBhbmQgPHR0PnRpdGxlPC90dD4gZnJvbSByZXNvdXJjZSBidW5kbGVzDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTkxIj5DTEstNTkxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBhIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2VJbnRlcmNlcHRvci5odG1sIj5QYWdlIEludGVyY2VwdG9yPC9hPg0KICAgICAgICBmYWNpbGl0eSB0aGF0IHByb3ZpZGVzIGFuIGV4dGVuc2lvbiBwb2ludCBmb3IgY29kZSB3aGljaCBjYW4gbGlzdGVuIHRvDQogICAgICAgIGtleSBwYWdlIGV2ZW50cyBhbmQgYWxzbyBpbnRlcnJ1cHQgbm9ybWFsIHBhZ2UgcHJvY2Vzc2luZyBmbG93Lg0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU5OCI+Q0xLLTU5ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgaW1wcm92ZWQgZHluYW1pYyBGb3JtIHN1cHBvcnQuIEZvcm1zIGNhbiBub3cgb3B0aW9uYWxseSBieXBhc3MNCiAgICAgICAgdmFsaWRhdGlvbiBmb3IgSmF2YVNjcmlwdCBiYXNlZCBzdWJtaXNzaW9ucyB1c2luZyB0aGUgbmV3IEphdmFTY3JpcHQNCiAgICAgICAgZnVuY3Rpb24gPHR0PiJDbGljay5zdWJtaXQoZm9ybSwgdmFsaWRhdGUpIjwvdHQ+DQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjM4Ij5DTEstNjM4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBpbXByb3ZlZCBkeW5hbWljIFBhZ2UgYW5kIEZvcm0gYmVoYXZpb3VyIHRocm91Z2ggbmV3IGhlbHBlciBtZXRob2RzDQogICAgICAgIHRoYXQgY2FuIGJpbmQgYW5kIHZhbGlkYXRlIEZvcm1zIGFuZCBGaWVsZHMgPHR0PmJlZm9yZTwvdHQ+IHRoZSBvblByb2Nlc3MNCiAgICAgICAgcGFnZSBldmVudCBlLmcuIGluIHRoZSBQYWdlIGNvbnN0cnVjdG9yIG9yIDx0dD4ib25Jbml0IjwvdHQ+IGV2ZW50Lg0KICAgICAgICBUaGUgbmV3IG1ldGhvZHMgYXJlOg0KICAgICAgICA8dWwgc3R5bGU9Im1hcmdpbi10b3A6IDEwcHg7Ij4NCiAgICAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCNiaW5kKG9yZy5hcGFjaGUuY2xpY2suY29udHJvbC5GaWVsZCkiPkNsaWNrVXRpbHMuYmluZChGaWVsZCk8L2E+DQogICAgICAgICAgICA8L2xpPg0KICAgICAgICAgICAgPGxpPg0KICAgICAgICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sI2JpbmQob3JnLmFwYWNoZS5jbGljay5jb250cm9sLkZvcm0pIj5DbGlja1V0aWxzLmJpbmQoRm9ybSk8L2E+DQogICAgICAgICAgICA8L2xpPg0KICAgICAgICAgICAgPGxpPg0KICAgICAgICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sI2JpbmQob3JnLmFwYWNoZS5jbGljay5jb250cm9sLkFic3RyYWN0TGluaykiPkNsaWNrVXRpbHMuYmluZChBYnN0cmFjdExpbmspPC9hPg0KICAgICAgICAgICAgPC9saT4NCiAgICAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCNiaW5kQW5kVmFsaWRhdGUob3JnLmFwYWNoZS5jbGljay5jb250cm9sLkZpZWxkKSI+Q2xpY2tVdGlscy5iaW5kQW5kVmFsaWRhdGUoRmllbGQpPC9hPg0KICAgICAgICAgICAgPC9saT4NCiAgICAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCNiaW5kQW5kVmFsaWRhdGUob3JnLmFwYWNoZS5jbGljay5jb250cm9sLkZvcm0pIj5DbGlja1V0aWxzLmJpbmRBbmRWYWxpZGF0ZShGb3JtKTwvYT4NCiAgICAgICAgICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYzOCI+Q0xLLTYzODwvYT5dDQogICAgICAgICAgICA8L2xpPg0KICAgICAgICA8L3VsPg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgaW1wcm92ZWQgZGlzYWJsZWQgYmVoYXZpb3IgdGhyb3VnaCB0aGUgZm9sbG93aW5nIGNoYW5nZXM6DQogICAgICAgIDx1bCBzdHlsZT0ibWFyZ2luLXRvcDoxMHB4Ij4NCiAgICAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICAgICBEaXNhYmxlZCBmaWVsZHMgYXJlIG5vdCBwcm9jZXNzZWQgb3IgdmFsaWRhdGVkDQogICAgICAgICAgICA8L2xpPg0KICAgICAgICAgICAgPGxpPg0KICAgICAgICAgICAgICAgIERpc2FibGVkIGZpZWxkIHZhbHVlcyBhcmUgbm90IGNvcGllZCB0byBkb21haW4gb2JqZWN0cw0KICAgICAgICAgICAgPC9saT4NCiAgICAgICAgICAgIDxsaT4NCiAgICAgICAgICAgICAgICBEaXNhYmxlZCBmaWVsZHMgYXJlIGF1dG9tYXRpY2FsbHkgZW5hYmxlZCBpZiB0aGUgZmllbGQgaGFzIGFuDQogICAgICAgICAgICAgICAgaW5jb21pbmcgcmVxdWVzdCBwYXJhbWV0ZXIsIGluZGljYXRpbmcgdGhhdCB0aGUgZmllbGQgd2FzIGVuYWJsZWQNCiAgICAgICAgICAgICAgICBvbiB0aGUgY2xpZW50IHVzaW5nIEphdmFTY3JpcHQuIFBsZWFzZSBub3RlIHRoYXQgdGhpcyBiZWhhdmlvciBkb2VzDQogICAgICAgICAgICAgICAgbm90IGFwcGx5IHRvIENoZWNrYm94IG9yIFJhZGlvIGZpZWxkcy4gU2VlIHRoZQ0KICAgICAgICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNzZXREaXNhYmxlZChib29sZWFuKSI+c2V0RGlzYWJsZWQoKTwvYT4NCiAgICAgICAgICAgICAgICBqYXZhZG9jIGZvciBkZXRhaWxzIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjQ2Ij5DTEstNjQ2PC9hPl0uDQogICAgICAgICAgICA8L2xpPg0KICAgICAgICA8L3VsPg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IG1ldGhvZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NvbnRhaW5lci5odG1sI3JlcGxhY2Uob3JnLmFwYWNoZS5jbGljay5Db250cm9sLCBvcmcuYXBhY2hlLmNsaWNrLkNvbnRyb2wpIj5Db250YWluZXIucmVwbGFjZTwvYT4NCiAgICAgICAgZm9yIHJlcGxhY2luZyBhbiBleGlzdGluZyBjb250cm9sIHdpdGggYSBuZXcgY29udHJvbC4gSW4gcHJldmlvdXMgcmVsZWFzZXMsDQogICAgICAgIGFuIGV4Y2VwdGlvbiB3b3VsZCBiZSByYWlzZWQgaWYgYSBwYWdlIG9yIGNvbnRhaW5lciBhbHJlYWR5IGNvbnRhaW5lZCBhDQogICAgICAgIGNvbnRyb2wgd2l0aCB0aGUgc2FtZSBuYW1lIGFzIHRoZSBuZXdseSBhZGRlZCBjb250cm9sLiBJbiAyLjIuMCB0aGUNCiAgICAgICAgcmVwbGFjZSBtZXRob2QgaXMgYXV0b21hdGljYWxseSBjYWxsZWQgd2hlbiBhZGRpbmcgYSBjb250cm9sIHdoaWNoIG5hbWUNCiAgICAgICAgbWF0Y2hlcyB0aGF0IG9mIGFuIGV4aXN0aW5nIGNvbnRyb2wgaW4gdGhlIHBhZ2Ugb3IgY29udGFpbmVyLiBUaGlzIGJlaGF2aW9yDQogICAgICAgIHdpbGwgbGlrZWx5IG9ubHkgYmVuZWZpdCA8dHQ+c3RhdGVmdWw8L3R0PiBwYWdlcyBzaW5jZSA8dHQ+c3RhdGVsZXNzPC90dD4NCiAgICAgICAgcGFnZXMgYXJlIHJlY3JlYXRlZCBlYWNoIHJlcXVlc3QNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NjYiPkNMSy02NjY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG1ldGhvZHMgdG8gRmllbGRzIGZvciBzdHlsaW5nIHRoZWlyIGxhYmVscy4gU2VlIG5ldyBtZXRob2RzDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNzZXRMYWJlbFN0eWxlKGphdmEubGFuZy5TdHJpbmcpIj5GaWVsZC5zZXRMYWJlbFN0eWxlKFN0cmluZyk8L2E+DQogICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwjc2V0TGFiZWxTdHlsZUNsYXNzKGphdmEubGFuZy5TdHJpbmcpIj5GaWVsZC5zZXRMYWJlbFN0eWxlQ2xhc3MoU3RyaW5nKTwvYT4uDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBTdGVmYXgNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01OTUiPkNMSy01OTU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG1ldGhvZHMgdG8gRmllbGRzIGZvciBwcm92aWRpbmcgc3R5bGluZyBoaW50cyB0byB0aGVpcg0KICAgICAgICBjb250YWluaW5nIGVsZW1lbnRzLiBTZWUgbmV3IG1ldGhvZHMNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI3NldFBhcmVudFN0eWxlSGludChqYXZhLmxhbmcuU3RyaW5nKSI+RmllbGQuc2V0UGFyZW50U3R5bGVIaW50KFN0cmluZyk8L2E+DQogICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwjc2V0UGFyZW50U3R5bGVDbGFzc0hpbnQoamF2YS5sYW5nLlN0cmluZykiPkZpZWxkLnNldFBhcmVudFN0eWxlQ2xhc3NIaW50KFN0cmluZyk8L2E+Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgU3RlZmF4DQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTk1Ij5DTEstNTk1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCB0cmltIHByb3BlcnR5IHRvIEZpZWxkIGZvciBjb250cm9sbGluZyBpZiB0aGUgRmllbGQgcmVxdWVzdA0KICAgICAgICBwYXJhbWV0ZXIgaXMgdHJpbW1lZCBvciBub3QuIFNlZSBuZXcgbWV0aG9kDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNzZXRUcmltKGJvb2xlYW4pIj5GaWVsZC5zZXRUcmltKGJvb2xlYW4pPC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFuZHJleSBSeWJpbg0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYyNyI+Q0xLLTYyNzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IENvbnRleHQgbWV0aG9kcw0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwjaGFzUmVxdWVzdFBhcmFtZXRlcihqYXZhLmxhbmcuU3RyaW5nKSI+Q29udGV4dC5oYXNSZXF1ZXN0UGFyYW1ldGVyKFN0cmluZyk8L2E+DQogICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwjaGFzUmVxdWVzdEF0dHJpYnV0ZShqYXZhLmxhbmcuU3RyaW5nKSI+Q29udGV4dC5oYXNSZXF1ZXN0QXR0cmlidXRlKFN0cmluZyk8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgc3VwcG9ydCB0byBTZWxlY3QgZm9yIGEgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9TZWxlY3QuaHRtbCNzZXREZWZhdWx0T3B0aW9uKG9yZy5hcGFjaGUuY2xpY2suY29udHJvbC5PcHRpb24pIj5kZWZhdWx0IG9wdGlvbjwvYT4NCiAgICAgICAgdGhhdCBjYW4gYmUgdXNlZCB0byB2YWxpZGF0ZSBub24gc2VsZWN0aW9uIGFnYWluc3QgYW5kIGFsbG93cyB0aGUgU2VsZWN0DQogICAgICAgIHRvIG9ubHkgcG9wdWxhdGUgaXRzIG9wdGlvbkxpc3QgYXQgcmVuZGVyaW5nIHRpbWUsIGluc3RlYWQgb2YgZHVyaW5nDQogICAgICAgIDx0dD5vblByb2Nlc3M8L3R0PiBldmVudC4NCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NDEiPkNMSy02NDE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIGRlZmF1bHQgYXV0b2JpbmRpbmcgbW9kZSB0byBiaW5kIGJvdGggcHVibGljIGZpZWxkcyBhbmQgZmllbGRzDQogICAgICAgIGFubm90YXRlZCB3aXRoIEBCaW5kYWJsZS4gSW4gcHJldmlvdXMgdmVyc2lvbnMgdGhlIGRlZmF1bHQgYXV0b2JpbmRpbmcNCiAgICAgICAgbW9kZSBvbmx5IGJpbmRlZCBwdWJsaWMgUGFnZSBmaWVsZHMNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NDgiPkNMSy02NDg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG1vY2sgc3VwcG9ydCBmb3IgdXNlciA8YSBocmVmPSJtb2NrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZsZXQvTW9ja1ByaW5jaXBhbC5odG1sIj5wcmluY2lwYWxzPC9hPg0KICAgICAgICBhbmQgcm9sZXMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgU3ZlbiBQZmVpZmZlcg0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU4NSI+Q0xLLTU4NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbG9jYWxpemVkIERhdGUgZm9ybWF0IHBhdHRlcm4gc3VwcG9ydC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5DQogICAgICAgIEFuZHJleSBSeWJpbg0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTYxMCI+Q0xLLTYxMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgUG9saXNoIHJlc291cmNlIGJ1bmRsZSBmb3IgRGF0ZUZpZWxkLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kDQogICAgICAgIGZpeGVkIGJ5IFJhZmFsIFJ1c2luDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjI0Ij5DTEstNjI0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBNaWdyYXRlZCBjb250cm9scyB0byBpbXBvcnQgcmVzb3VyY2VzIHRocm91Z2ggRWxlbWVudHMgYW5kIHRoZQ0KICAgICAgICA8dHQ+Z2V0SGVhZEVsZW1lbnRzPC90dD4gbWV0aG9kDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjQ3Ij5DTEstNjQ3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBTcHJpbmdDbGlja1NlcnZsZXQgdG8gcmUtaW5qZWN0IHRyYW5zaWVudCBiZWFucyBhZnRlciBzdGF0ZWZ1bA0KICAgICAgICBwYWdlIGRlc2VyaWFsaXphdGlvbi4gVGhpcyBmZWF0dXJlIGlzIG9ubHkgc3VwcG9ydGVkIHdoZW4gdGhlIHN0YXRlZnVsDQogICAgICAgIHBhZ2UgaW5zdGFuY2UgaXMgY3JlYXRlZCBieSBDbGljaywgbm90IFNwcmluZw0KICAgICAgICBbPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY2NyI+Q0xLLTY2NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgUmVwbGFjZWQgUGFnZSBhbmQgQ29udHJvbCBnZXRNZXNzYWdlIG1ldGhvZHMgd2l0aCB2YXJhcmdzIGVxdWl2YWxlbnRzDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjA0Ij5DTEstNjA0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZW1vdmVkIENsaWNrIGNvcmUncyBkZXBlbmRlbmN5IG9uIFZlbG9jaXR5LiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgYnkgQW5kcmV5IFJ5YmluDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjA2Ij5DTEstNjA2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZXBsYWNlZCBtdWx0aXBsZSBDbGlja1V0aWxzIGNsb3NlIG1ldGhvZHMgd2l0aCBhIHNpbmdsZSBtZXRob2QgYWNjZXB0aW5nDQogICAgICAgIGEgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwjY2xvc2UoamF2YS5pby5DbG9zZWFibGUpIj5DbG9zZWFibGU8L2E+Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQW5kcmV5IFJ5YmluDQogICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjIwIj5DTEstNjIwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBDbGlja1NlcnZsZXQgdG8gdXNlIHRoZSByZXNwb25zZSdzIE91dHB1dFN0cmVhbSBpZiB0aGUgV3JpdGVyDQogICAgICAgIGNhbm5vdCBiZSByZXRyaWV2ZWQNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NDQiPkNMSy02NDQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIGlzc3VlIHdoZXJlIFJhZGlvR3JvdXAgbGFiZWwgcmVmZXJlbmNlZCBhIG5vbi1leGlzdGluZyBJRC4gUmFkaW9Hcm91cA0KICAgICAgICBpcyBub3cgd3JhcHBlZCBpbnNpZGUgYSBzcGFuIHRhZyB3aXRoIHRoZSBnaXZlbiBJRC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkDQogICAgICAgIGFuZCBmaXhlZCBieSBGaW5uIEJvY2sNCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NzciPkNMSy01Nzc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIERhdGVGaWVsZCB0byBzZXQgc2Vjb25kcyBiYWNrIHRvIHplcm8uIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBbmRyZXkgUnliaW4NCiAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02NjQiPkNMSy02NjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgVGhlIG1lbnUuZHRkIGhhcyBiZWVuIHB1Ymxpc2hlZCB0bw0KICAgICAgICAgIDxhIGhyZWY9Imh0dHA6Ly9jbGljay5hcGFjaGUub3JnL2R0ZHMvbWVudS0yLjIuZHRkIj5odHRwOi8vY2xpY2suYXBhY2hlLm9yZy9kdGRzL21lbnUtMi4yLmR0ZDwvYT4uDQogICAgICAgICAgSWYgeW91IHdhbnQgeW91ciBjb25maWd1cmF0aW9uIHRvIGNvbmZvcm0gdG8gdGhlIG1lbnUuZHRkLCBpbmNsdWRlDQogICAgICAgICAgdGhlIGZvbGxvd2luZyBkZWNsYXJhdGlvbiBpbiB5b3VyIG1lbnUueG1sOg0KICAgICAgICAgIDxwcmUgY2xhc3M9InByZXR0eXByaW50Ij4mbHQ7IURPQ1RZUEUgbWVudSBQVUJMSUMNCiAgICAgICAiLS8vQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24vL0RURCBDbGljayBNZW51IDIuMi8vRU4iDQogICAgICAgImh0dHA6Ly9jbGljay5hcGFjaGUub3JnL2R0ZHMvbWVudS0yLjIuZHRkIiZndDsgPC9wcmU+DQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIFRoZSBuZXcgY2xpY2stMi4yLmR0ZCBoYXMgYmVlbiBwdWJsaXNoZWQgdG8NCiAgICAgICAgICA8YSBocmVmPSJodHRwOi8vY2xpY2suYXBhY2hlLm9yZy9kdGRzL2NsaWNrLTIuMi5kdGQiPmh0dHA6Ly9jbGljay5hcGFjaGUub3JnL2R0ZHMvY2xpY2stMi4yLmR0ZDwvYT4uDQogICAgICAgICAgSWYgeW91IHdhbnQgeW91ciBjb25maWd1cmF0aW9uIHRvIGNvbmZvcm0gdG8gdGhlIGNsaWNrLmR0ZCwgaW5jbHVkZQ0KICAgICAgICAgIHRoZSBmb2xsb3dpbmcgZGVjbGFyYXRpb24gaW4geW91ciBjbGljay54bWw6DQogICAgICAgICAgPHByZSBjbGFzcz0icHJldHR5cHJpbnQiPiZsdDshRE9DVFlQRSBjbGljay1hcHAgUFVCTElDDQogICAgICAgIi0vL0FwYWNoZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLy9EVEQgQ2xpY2sgQ29uZmlndXJhdGlvbiAyLjIvL0VOIg0KICAgICAgICJodHRwOi8vY2xpY2suYXBhY2hlLm9yZy9kdGRzL2NsaWNrLTIuMi5kdGQiJmd0OyA8L3ByZT4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgVXBkYXRlZCBWZWxvY2l0eSBsaWJyYXJ5IHRvIHZlcnNpb24gMS42LjQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIFVwZGF0ZWQgQ2F5ZW5uZSBsaWJyYXJ5IHRvIHZlcnNpb24gMy4wLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KDQogIDxkdD48YSBuYW1lPSIyLjIuMC1SQzEiPjwvYT5WZXJzaW9uIDIuMi4wLVJDMSAtIDggTWF5IDIwMTA8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgU2VlIHRoZSByZWxlYXNlIG5vdGVzIGZvciA8YSBocmVmPSIjMi4yLjAiPjIuMi4wPC9hPi4NCiAgICA8L2Rpdj4NCiAgPC9kZD4NCg0KICA8ZHQ+PGEgbmFtZT0iMi4xLjAiPjwvYT4NCiAgICA8ZGl2PlZlcnNpb24gMi4xLjAgLSAxMCBGZWJydWFyeSAyMDEwPC9kaXY+DQogIDwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICBJTVBPUlRBTlQgYmUgc3VyZSB0byByZWFkIHRoZSA8YSBocmVmPSJ1cGdyYWRlLXBhdGguaHRtbCI+dXBncmFkZSBwYXRoPC9hPg0KICAgICAgd2hlbiB1cGdyYWRpbmcgZnJvbSBwcmV2aW91cyByZWxlYXNlcy4NCiAgICA8L2Rpdj4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICA8Yj5QbGVhc2UgTm90ZTo8L2I+DQogICAgICBUaGlzIHJlbGVhc2UgcmVxdWlyZXMgSmF2YSAxLjUgb3IgbGF0ZXIuDQogICAgPC9kaXY+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIDxiPk5ldyBleGFtcGxlczo8L2I+DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpPg0KICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL2dlbmVyYWwvcGFnZS1oZWFkLWRlbW8uaHRtIj4NCiAgICAgICAgUGFnZSBIRUFEIGVsZW1lbnRzPC9hPiBkZW1vbnN0cmF0ZXMgaG93IHRvIGFkZA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L0pzSW1wb3J0Lmh0bWwiPkpzSW1wb3J0PC9hPiwNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Kc1NjcmlwdC5odG1sIj5Kc1NjcmlwdDwvYT4sDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvQ3NzSW1wb3J0Lmh0bWwiPkNzc0ltcG9ydDwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvQ3NzU3R5bGUuaHRtbCI+Q3NzU3R5bGU8L2E+DQogICAgICAgIEhFQUQgZWxlbWVudHMgdG8gYSBQYWdlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9nZW5lcmFsL2NvbnRyb2wtaGVhZC1kZW1vLmh0bSI+DQogICAgICAgIENvbnRyb2wgSEVBRCBlbGVtZW50czwvYT4gZGVtb25zdHJhdGVzIGhvdyB0byBhZGQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Kc0ltcG9ydC5odG1sIj5Kc0ltcG9ydDwvYT4gYW5kDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvQ3NzSW1wb3J0Lmh0bWwiPkNzc0ltcG9ydDwvYT4NCiAgICAgICAgSEVBRCBlbGVtZW50cyB0byBhIGN1c3RvbSBDb250cm9sLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9jb250cm9sL3N1Ym1pdC1saW5rLWRlbW8uaHRtIj4NCiAgICAgICAgICBTdWJtaXRMaW5rIERlbW88L2E+IHNob3dzIGhvdyB0byB1c2UgdGhlIG5ldyA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvU3VibWl0TGluay5odG1sIj5TdWJtaXRMaW5rPC9hPiBjb250cm9sLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy90YWJsZS9sYXJnZS1kYXRhc2V0LWRlbW8uaHRtIj4NCiAgICAgICAgTGFyZ2UgRGF0YXNldDwvYT4gaXMgYW4gZXhhbXBsZSBvZiBhIFRhYmxlIHdpdGggYSBsYXJnZSBudW1iZXIgb2Ygcm93cw0KICAgICAgICBhbmQgaG93IHRvIGxhemlseSBwYWdlIHRocm91Z2ggdGhlIHJvd3MgdXNpbmcgYSBjdXN0b20gZGF0YSBwcm92aWRlci4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvcGFuZWwvcmV1c2FibGUtcGFuZWwtZGVtby5odG0iPg0KICAgICAgICAgIFJldXNhYmxlIFBhbmVsPC9hPiBpcyBhbiBleGFtcGxlIG9mIGEgcmV1c2FibGUgUGFuZWwNCiAgICAgICAgICB3aGljaCBwcm92aWRlcyBhIEZvcm0gZm9yIGNhcHR1cmluZyBDbGllbnQgZGV0YWlscy4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvcXVhcnR6L3F1YXJ0ei1qb2Itc2NoZWR1bGVyLmh0bSI+DQogICAgICAgICAgUXVhcnR6IEpvYiBTY2hlZHVsZXI8L2E+IGlzIGFuIGV4YW1wbGUgZGVtb25zdHJhdGluZyBob3cgdG8gaW50ZWdyYXRlIHRoZSBRdWFydHogSm9iIFNjaGVkdWxpbmcgZnJhbWV3b3JrDQogICAgICAgICAgaW50byBhIENsaWNrIGFwcGxpY2F0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgPGEgdGFyZ2V0PSJfYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL2NsaWNrLmF2b2thLmNvbS9jbGljay1leGFtcGxlcy9nZW5lcmFsL2V4Y2VsLXRhYmxlLWV4cG9ydC5odG0iPg0KICAgICAgICAgIEV4Y2VsIFRhYmxlIEV4cG9ydGVyPC9hPiBleGFtcGxlIGRlbW9uc3RyYXRlcyBob3cgdG8gZXhwb3J0IGEgQ2xpY2sgVGFibGUNCiAgICAgICAgICB0byBhbiBFeGNlbCBzcHJlYWRzaGVldCB1c2luZw0KICAgICAgICAgIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9wb2kuYXBhY2hlLm9yZy8iPkFwYWNoZSBQT0k8L2E+Lg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KDQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIDxiPk5ldyBkb2N1bWVudGF0aW9uOjwvYj4NCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtO21hcmdpbi1ib3R0b206IDJlbSI+DQogICAgICA8bGk+DQogICAgICAgIERvY3VtZW50YXRpb24gaGFzIGJlZW4gY29udmVydGVkIHRvIERvY2Jvb2sgYW5kIGFyZSBtYWRlIGF2YWlsYWJsZSBpbg0KICAgICAgICB0aHJlZSBkaWZmZXJlbnQgZmxhdm9yczogPGEgaHJlZj0idXNlci1ndWlkZS5odG1sIj5QREYsIEhUTUwgKHNpbmdsZSBwYWdlKSBhbmQgSFRNTCAobXVsdGlwbGUgcGFnZXMpPC9hPi4NCiAgICAgICAgVGhhbmtzIHRvIEdpbGJlcnRvIEMgQW5kcmFkZSBmb3IgZG9pbmcgdGhlIGNvbnZlcnNpb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00ODIiPjQ4MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgQWRkZWQgZG9jdW1lbnRhdGlvbiBkZXNjcmliaW5nIHRoZSBuZXcgSEVBRCBlbGVtZW50IHN1cHBvcnQuDQogICAgICAgIFBsZWFzZSBzZWUgdGhlIG5ldyBzZWN0aW9uIG9uIFBhZ2UgSEVBRCBlbGVtZW50cw0KICAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMxMy5odG1sIj5oZXJlPC9hPiBhbmQNCiAgICAgICAgdGhlIHNlY3Rpb24gb24gQ29udHJvbCBIRUFEIGVsZW1lbnRzIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAzczA1Lmh0bWwiPmhlcmU8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaT4NCiAgICAgICAgQWRkZWQgYSBuZXcgc2VjdGlvbiwgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDRzMDMuaHRtbCNkZXBsb3lpbmctcmVzdHJpY3RlZC1lbnYiPkRlcGxveWluZyByZXNvdXJjZXMgaW4gYSByZXN0cmljdGVkIGVudmlyb25tZW50PC9hPiwNCiAgICAgICAgZGVzY3JpYmluZyBob3cgdG8gZGVwbG95IHN0YXRpYyByZXNvdXJjZXMgaW4gZW52aXJvbm1lbnRzIHdoZXJlDQogICAgICAgIFdBUi9FQVIgYXJlIG5vdCB1bnBhY2tlZCBvciB3aGVyZSBmaWxlIHN5c3RlbSBwZXJtaXNzaW9ucyBhcmUNCiAgICAgICAgcmVzdHJpY3RlZCwgc3VjaCBhcw0KICAgICAgICA8YSBjbGFzcz0iZXh0ZXJuYWwiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vY29kZS5nb29nbGUuY29tL2FwcGVuZ2luZS9kb2NzL2phdmEvb3ZlcnZpZXcuaHRtbCI+R29vZ2xlIEFwcCBFbmdpbmU8L2E+Lg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KDQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIDxiPkRlcHJlY2F0ZWQ6PC9iPg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBEZXByZWNhdGVkIG1ldGhvZHM6IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNnZXRIdG1sSW1wb3J0cygpIj5Db250cm9sLmdldEh0bWxJbXBvcnRzKCk8L2E+IGFuZA0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNnZXRIdG1sSW1wb3J0cygpIj5QYWdlLmdldEh0bWxJbXBvcnRzKCk8L2E+Lg0KICAgICAgICAgIFRoZXNlIG1ldGhvZHMgaGF2ZSBiZWVuIGRlcHJlY2F0ZWQgaW4gZmF2b3Igb2YNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwjZ2V0SGVhZEVsZW1lbnRzKCkiPkNvbnRyb2wuZ2V0SGVhZEVsZW1lbnRzKCk8L2E+DQogICAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNnZXRIZWFkRWxlbWVudHMoKSI+UGFnZS5nZXRIZWFkRWxlbWVudHMoKTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIERlcHJlY2F0ZWQgbWV0aG9kczogPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI2dldFBhZ2VJbXBvcnRzKCkiPlBhZ2UuZ2V0UGFnZUltcG9ydHMoKTwvYT4NCiAgICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3NldFBhZ2VJbXBvcnRzKG9yZy5hcGFjaGUuY2xpY2sudXRpbC5QYWdlSW1wb3J0cykiPlBhZ2Uuc2V0UGFnZUltcG9ydHMoKTwvYT4uDQogICAgICAgICAgVGhlc2UgbWV0aG9kcyBoYXZlIGJlZW4gZGVwcmVjYXRlZCBpbiBmYXZvciBvZg0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNnZXRIZWFkRWxlbWVudHMoKSI+UGFnZS5nZXRIZWFkRWxlbWVudHMoKTwvYT4uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQoNCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgPGI+TmV3IGZlYXR1cmVzIGFuZCBpc3N1ZXMgcmVzb2x2ZWQ6PC9iPg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciA8YSBjbGFzcz0iZXh0ZXJuYWwiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vY29kZS5nb29nbGUuY29tL2FwcGVuZ2luZS9kb2NzL2phdmEvb3ZlcnZpZXcuaHRtbCI+R29vZ2xlIEFwcCBFbmdpbmU8L2E+LA0KICAgICAgICAgIGEgZnJlZSBKYXZhIGhvc3RpbmcgZW52aXJvbm1lbnQgZnJvbSBHb29nbGUuIFRoaXMgcHJvdmlkZXMgYW4gaWRlYWwNCiAgICAgICAgICBlbnZpcm9ubWVudCBmb3Igc3R1ZGVudHMgYW5kIHN0YXJ0dXBzIHRvIGVhc2lseSBob3N0IHRoZWlyIENsaWNrDQogICAgICAgICAgYXBwbGljYXRpb25zIG9ubGluZS4gU2VlIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvZ2FlL0dvb2dsZUFwcEVuZ2luZUxpc3RlbmVyLmh0bWwiPkdvb2dsZUFwcEVuZ2luZUxpc3RlbmVyPC9hPg0KICAgICAgICAgIGZvciBkZXRhaWxzDQogICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NjAiPjU2MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBhbiBpbi1tZW1vcnkgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9nYWUvTWVtb3J5RmlsZVVwbG9hZFNlcnZpY2UuaHRtbCI+RmlsZSBVcGxvYWQgU2VydmljZTwvYT4NCiAgICAgICAgICB0aGF0IGNhbiBiZSB1c2VkIGZvciB1cGxvYWRpbmcgZmlsZXMgaW4gYSA8YSBjbGFzcz0iZXh0ZXJuYWwiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vY29kZS5nb29nbGUuY29tL2FwcGVuZ2luZS9kb2NzL2phdmEvb3ZlcnZpZXcuaHRtbCI+R29vZ2xlIEFwcCBFbmdpbmU8L2E+DQogICAgICAgICAgZW52aXJvbm1lbnQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIHRlbXBsYXRlcyB3aXRoIGN1c3RvbSBleHRlbnNpb25zIHRocm91Z2ggdGhlIG5ldw0KICAgICAgICAgIENvbmZpZ1NlcnZpY2UuPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svc2VydmljZS9Db25maWdTZXJ2aWNlLmh0bWwjaXNUZW1wbGF0ZShqYXZhLmxhbmcuU3RyaW5nKSI+aXNUZW1wbGF0ZTwvYT4NCiAgICAgICAgICBtZXRob2QuIFRoZSBkZWZhdWx0IENvbmZpZ1NlcnZpY2UgaW1wbGVtZW50YXRpb24sIFhtbENvbmZpZ1NlcnZpY2UsIHByb3ZpZGVzDQogICAgICAgICAgc3VwcG9ydCBmb3IgdGhlIGV4dGVuc2lvbnMgPHR0Pi5odG08L3R0PiBhbmQgPHR0Pi5qc3A8L3R0PiwgYnV0IG5ldyBleHRlbnNpb25zDQogICAgICAgICAgY2FuIGJlIHByb3ZpZGVkIGluIGEgc3ViY2xhc3MuIFNlZSB0aGUgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svc2VydmljZS9YbWxDb25maWdTZXJ2aWNlLmh0bWwjaXNUZW1wbGF0ZShqYXZhLmxhbmcuU3RyaW5nKSI+SmF2YURvYzwvYT4NCiAgICAgICAgICBmb3IgZGV0YWlscw0KICAgICAgICAgIFs8YSB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTY4Ij41Njg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgc3VwcG9ydCB0byB0aGUgUGFnZSBjbGFzcyBmb3IgY29uZGl0aW9uYWxseSBpbmNsdWRpbmcgQ29udHJvbA0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNnZXRIZWFkRWxlbWVudHMoKSI+aGVhZCBlbGVtZW50czwvYT4NCiAgICAgICAgICB0aHJvdWdoIHRoZSBuZXcgbWV0aG9kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzZXRJbmNsdWRlQ29udHJvbEhlYWRFbGVtZW50cyhib29sZWFuKSI+aW5jbHVkZUNvbnRyb2xIZWFkRWxlbWVudHM8L2E+DQogICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NzEiPjU3MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBzdXBwb3J0IHRvIGRlcGxveSByZXNvdXJjZXMgaW5zaWRlIEpBUnMgZnJvbSB0aGUgU2VydmxldCAzLjAgY29tcGxpYW50DQogICAgICAgICAgbG9jYXRpb24sIDx0dD5NRVRBLUlORi9yZXNvdXJjZXM8L3R0Pi4gQ2xpY2sncyBvd24gcHJlLXBhY2thZ2VkIHJlc291cmNlcw0KICAgICAgICAgIGFyZSBub3cgYWxzbyBsb2NhdGVkIGluIHRoZSBKQVIgdW5kZXIgPHR0Pk1FVEEtSU5GL3Jlc291cmNlczwvdHQ+DQogICAgICAgICAgWzxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NzAiPjU3MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBuZXcgQ2FsZW5kYXIgcG9wdXAgdG8gRGF0ZUZpZWxkLiBUaGlzIENhbGVuZGFyIHBvcHVwIHVzZXMNCiAgICAgICAgICA8YSB0YXJnZXQ9Il9ibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vY29kZS5nb29nbGUuY29tL3AvY2FsZW5kYXJkYXRlc2VsZWN0LyI+Q2FsZW5kYXIgRGF0ZSBTZWxlY3Q8L2E+DQogICAgICAgICAgd2hpY2ggaXMgYmFzZWQgb24gdGhlIFByb3RvdHlwZSBKYXZhU2NyaXB0IGxpYnJhcnkuDQogICAgICAgICAgPHAvPg0KICAgICAgICAgIFBsZWFzZSBub3RlIGlmIHlvdSBkb24ndCB3YW50IGEgZGVwZW5kZW5jeSBvbiB0aGUgUHJvdG90eXBlIGxpYnJhcnkNCiAgICAgICAgICB5b3UgY2FuIHVzZSB0aGUgdGhpcmQtcGFydHkNCiAgICAgICAgICA8YSBjbGFzcz0iZXh0ZXJuYWwiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vY29kZS5nb29nbGUuY29tL3AvY2xpY2stY2FsZW5kYXIvIj5DbGljayBDYWxlbmRhcjwvYT4NCiAgICAgICAgICBpbnN0ZWFkLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBmaXJzdCBjbGFzcyBzdXBwb3J0IGZvciBIRUFEIGVsZW1lbnRzIHN1Y2ggYXMgSmF2YVNjcmlwdCBhbmQgQ3NzLg0KICAgICAgICAgIFRoZSBmb2xsb3dpbmcgY2xhc3NlcyB3ZXJlIGFkZGVkOg0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvRWxlbWVudC5odG1sIj5FbGVtZW50PC9hPiwNCiAgICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9lbGVtZW50L1Jlc291cmNlRWxlbWVudC5odG1sIj5SZXNvdXJjZUVsZW1lbnQ8L2E+LA0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvSnNJbXBvcnQuaHRtbCI+SnNJbXBvcnQ8L2E+LA0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvSnNTY3JpcHQuaHRtbCI+SnNTY3JpcHQ8L2E+LA0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2VsZW1lbnQvQ3NzSW1wb3J0Lmh0bWwiPkNzc0ltcG9ydDwvYT4NCiAgICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svZWxlbWVudC9Dc3NTdHlsZS5odG1sIj5Dc3NTdHlsZTwvYT4uDQogICAgICAgICAgQSBuZXcgbWV0aG9kIHdhcyBhZGRlZCB0byBQYWdlIGFuZCBDb250cm9sOiA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwjZ2V0SGVhZEVsZW1lbnRzKCkiPkNvbnRyb2wuZ2V0SGVhZEVsZW1lbnRzKCk8L2E+DQogICAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNnZXRIZWFkRWxlbWVudHMoKSI+UGFnZS5nZXRIZWFkRWxlbWVudHMoKTwvYT4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUwMSI+NTAxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9TdWJtaXRMaW5rLmh0bWwiPlN1Ym1pdExpbms8L2E+IGNvbnRyb2wNCiAgICAgICAgICB0aGF0IGNhbiBzdWJtaXQgYSBGb3JtIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTE5Ij41MTk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgICAgQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0hpZGRlbkxpc3QuaHRtbCI+SGlkZGVuTGlzdDwvYT4gY29udHJvbA0KICAgICAgICAgIGZvciByZW5kZXJpbmcgYW5kIHN1Ym1pdHRpbmcgYSBsaXN0IG9mIGhpZGRlbiBmaWVsZHMgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00OTEiPjQ5MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBwbHVnZ2FibGUgc2VjdXJpdHkgYWNjZXNzIGNvbnRyb2xsZXIgKDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvc2VjdXJpdHkvQWNjZXNzQ29udHJvbGxlci5odG1sIj5BY2Nlc3NDb250cm9sbGVyPC9hPikgdG8gTWVudSBjbGFzcy4NCiAgICAgICAgICBUaGlzIHBsdWdnYWJsZSBpbnRlcmZhY2UgZW5hYmxlIHVzZSBvZiBzZWN1cml0eSBmcmFtZXdvcmtzIHN1Y2ggYXMgU3ByaW5nIFNlY3VyaXR5IChBY2VnaSkgb3IgSlNlY3VyaXR5IHRvIGNvbnRyb2wgdXNlciBhY2Nlc3MgdG8gTWVudSBpdGVtcy4NCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGVtZXRyaW9zIEt5cmlha2lzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2NsaWNrL2Jyb3dzZS9DTEstNDA2Ij40MDY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgYW4gQW50IHRhc2ssIGNhbGxlZCBEZXBsb3lUYXNrLCBmb3IgZGVwbG95aW5nIHN0YXRpYyByZXNvdXJjZXMNCiAgICAgICAgICBhdCBidWlsZCB0aW1lLiBUaGlzIHRhc2sgaXMgdXNlZnVsIHdoZW4gZGVwbG95aW5nIENsaWNrIGFwcGxpY2F0aW9ucw0KICAgICAgICAgIGluIHJlc3RyaWN0ZWQgZW52aXJvbm1lbnRzLiBGb3IgbW9yZSBkZXRhaWxzIHNlZSB0aGUgc2VjdGlvbjoNCiAgICAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMy5odG1sI2RlcGxveWluZy1yZXN0cmljdGVkLWVudiI+ZGVwbG95aW5nIHJlc291cmNlcyBpbiBhIHJlc3RyaWN0ZWQgZW52aXJvbm1lbnQ8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBhIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvUmVzb3VyY2VTZXJ2aWNlLmh0bWwiPlJlc291cmNlU2VydmljZTwvYT4sDQogICAgICAgICAgZm9yIHNlcnZpbmcgc3RhdGljIHJlc291cmNlcyBhdCBydW50aW1lLiBUaGlzIHNlcnZpY2UgaXMgdXNlZnVsIHdoZW4NCiAgICAgICAgICBkZXBsb3lpbmcgQ2xpY2sgYXBwbGljYXRpb25zIGluIHJlc3RyaWN0ZWQgZW52aXJvbm1lbnRzLiBGb3IgbW9yZSBkZXRhaWxzDQogICAgICAgICAgc2VlIHRoZSBzZWN0aW9uOg0KICAgICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAzLmh0bWwjZGVwbG95aW5nLXJlc3RyaWN0ZWQtZW52Ij5kZXBsb3lpbmcgcmVzb3VyY2VzIGluIGEgcmVzdHJpY3RlZCBlbnZpcm9ubWVudDwvYT4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvY2xpY2svYnJvd3NlL0NMSy01NjQiPjU2NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCBtZXRob2QsDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwjY3JlYXRlVGVtcGxhdGVNb2RlbChvcmcuYXBhY2hlLmNsaWNrLlBhZ2UsIG9yZy5hcGFjaGUuY2xpY2suQ29udGV4dCkiPkNsaWNrVXRpbHMuY3JlYXRlVGVtcGxhdGVNb2RlbDwvYT4sDQogICAgICAgICAgd2hpY2ggcmV0dXJucyBhIHRlbXBsYXRlIG1vZGVsIGNvbnRhaW5pbmcgb2JqZWN0cyBzdWNoIGFzIHRoZSBDb250ZXh0DQogICAgICAgICAgcGF0aCwgUGFnZSBwYXRoLCBIVFRQIHJlcXVlc3QsIEhUVFAgcmVzcG9uc2UsIEhUVFAgc2Vzc2lvbiBldGMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIGFiaWxpdHkgdG8gc3BlY2lmeSBhIGN1c3RvbSBUcmVlTm9kZSBpY29uIHRocm91Z2ggdGhlIG5ldyBtZXRob2QNCiAgICAgICAgICBUcmVlTm9kZS48YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZU5vZGUuaHRtbCNzZXRJY29uKGphdmEubGFuZy5TdHJpbmcpIj5zZXRJY29uKFN0cmluZyk8L2E+Lg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgVGltIEhvb3Blcg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDk0Ij40OTQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgbWV0aG9kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvRm9ybWF0Lmh0bWwjdXJsKGphdmEubGFuZy5PYmplY3QpIj5Gb3JtYXQudXJsPC9hPg0KICAgICAgICAgIGZvciBlbmNvZGluZyBVUkwncyBpbiB0ZW1wbGF0ZXMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM5OSI+Mzk5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIG1ldGhvZA0KICAgICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9GaWVsZENvbHVtbi5odG1sI3NldFByb3BlcnR5KGphdmEubGFuZy5PYmplY3QsIGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5PYmplY3QpIj5GaWVsZENvbHVtbi5zZXRQcm9wZXJ0eTwvYT4NCiAgICAgICAgICB0aGF0IGNhbiBiZSBvdmVycmlkZW4gdG8gcHJvdmlkZSBjdXN0b20gYmluZGluZyBmb3IgY29tcGxleA0KICAgICAgICAgIGRvbWFpbiBvYmplY3RzLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFdhcm5lckphbiBWZWxkaHVpcw0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTI4Ij41Mjg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgQWRkZWQgVHlwZUNvbnZlcnRlciBjb25maWd1cmF0aW9uIG9wdGlvbiB0byBDbGlja1NlcnZsZXQuDQogICAgICAgICAgU2VlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NsaWNrU2VydmxldC5odG1sI2dldFR5cGVDb252ZXJ0ZXIoKSI+Z2V0VHlwZUNvbnZlcnRlcigpPC9hPg0KICAgICAgICAgIG1ldGhvZCBmb3IgZGV0YWlscy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIEpvc2VwaCBTY2htaWR0IGFuZCBmaXhlZCBieSBBZHJpYW4gQS4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUzOSI+NTM5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvc2VydmljZS9TbGY0akxvZ1NlcnZpY2UuaHRtbCI+U2xmNGpMb2dTZXJ2aWNlPC9hPg0KICAgICAgICAgIGZvciBzdXBwb3J0aW5nIG11bHRpcGxlIGFwcGxpY2F0aW9uIHNlcnZlcnMuDQogICAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIE9saXZlciBCdXJuDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NTUiPjU1NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0JpbmRhYmxlLmh0bWwiPkBCaW5kYWJsZTwvYT4NCiAgICAgICAgICBhbm5vdGF0aW9uIHN1cHBvcnQgZm9yIHBhZ2UgZmllbGQgYXV0b2JpbmRpbmcuIEBCaW5kYWJsZSBzdXBwb3J0cyBwdWJsaWMsDQogICAgICAgICAgcHJvdGVjdGVkIGFuZCBwcml2YXRlIFBhZ2UgdmFyaWFibGVzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NTYiPjU1NjwvYT4sDQogICAgICAgICAgIDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01OTkiPjU5OTwvYT4NCiAgICAgICAgICBdLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgcHJvcGVydHkgZmlsZXMgd2l0aCB0cmFuc2xhdGlvbiBmb3IgdGhlIFJ1c3NpYW4gbGFuZ3VhZ2UuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQW5kcmV5IFJ5YmluDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjA3Ij42MDc8L2E+XSwNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MTEiPjYxMTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG5ldyBUcmVlIG1ldGhvZHMNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL1RyZWUuaHRtbCNzZXRXaWR0aChqYXZhLmxhbmcuU3RyaW5nKSI+c2V0V2lkdGg8L2E+IC8NCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL1RyZWUuaHRtbCNnZXRXaWR0aCgpIj5nZXRXaWR0aDwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9UcmVlLmh0bWwjc2V0SGVpZ2h0KGphdmEubGFuZy5TdHJpbmcpIj5zZXRIZWlnaHQ8L2E+IC8NCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy90cmVlL1RyZWUuaHRtbCNnZXRIZWlnaHQoKSI+Z2V0SGVpZ2h0PC9hPi4NCiAgICAgICAgQWxzbyBmaXhlZCByZW5kZXJpbmcgaXNzdWVzIGluIElFNi83IGZvciBsb25nIG5vZGUgbGFiZWxzIHRoYXQgb3ZlcmZsb3cNCiAgICAgICAgdGhlIHRyZWUgd2lkdGggWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MTYiPjYxNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBUaGUgY2xpY2suZHRkIGhhcyBiZWVuIHB1Ymxpc2hlZCB0bw0KICAgICAgICAgIDxhIGhyZWY9Imh0dHA6Ly9jbGljay5hcGFjaGUub3JnL2R0ZHMvY2xpY2stMi4xLmR0ZCI+aHR0cDovL2NsaWNrLmFwYWNoZS5vcmcvZHRkcy9jbGljay0yLjEuZHRkPC9hPi4NCiAgICAgICAgICBJZiB5b3Ugd2FudCB5b3VyIGNvbmZpZ3VyYXRpb24gdG8gY29uZm9ybSB0byB0aGUgY2xpY2suZHRkLCBpbmNsdWRlDQogICAgICAgICAgdGhlIGZvbGxvd2luZyBkZWNsYXJhdGlvbiBpbiB5b3VyIGNsaWNrLnhtbDoNCiAgICAgICAgICA8cHJlIGNsYXNzPSJwcmV0dHlwcmludCI+Jmx0OyFET0NUWVBFIGNsaWNrLWFwcCBQVUJMSUMNCiAgICAgICAiLS8vQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24vL0RURCBDbGljayBDb25maWd1cmF0aW9uIDIuMS8vRU4iDQogICAgICAgImh0dHA6Ly9jbGljay5hcGFjaGUub3JnL2R0ZHMvY2xpY2stMi4xLmR0ZCImZ3Q7IDwvcHJlPg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBGb3JtIHZhbGlkYXRpb24gdG8gYWxsb3cgRm9ybSBzdWJjbGFzc2VzIHRvIG92ZXJyaWRlIHRoZQ0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI3ZhbGlkYXRlKCkiPnZhbGlkYXRlPC9hPg0KICAgICAgICAgIG1ldGhvZCBhbmQgaW1wbGVtZW50IGNyb3NzLWZpZWxkIHZhbGlkYXRpb24uIFRoZSBmb2xsb3dpbmcNCiAgICAgICAgICBjaGFuZ2VzIHdlcmUgbWFkZTogdGhlIHByZXZpb3VzIDx0dD52YWxpZGF0ZTwvdHQ+IG1ldGhvZCB3YXMgcmVuYW1lZA0KICAgICAgICAgIHRvIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI3ZhbGlkYXRlRmlsZVVwbG9hZCgpIj52YWxpZGF0ZUZpbGVVcGxvYWQ8L2E+DQogICAgICAgICAgYW5kIGEgbmV3IGVtcHR5IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI3ZhbGlkYXRlKCkiPnZhbGlkYXRlPC9hPg0KICAgICAgICAgIG1ldGhvZCB3YXMgaW50cm9kdWNlZCwgdGhhdCBjYW4gc2FmZWx5IGJlIG92ZXJyaWRkZW4gaW4gc3ViY2xhc3Nlcw0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTcyIj41NzI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgUGFnZSByZWRpcmVjdCB0byBzdXBwb3J0IHBhcmFtZXRlcnMuIFNlZSB0aGUgbmV3IFBhZ2UgbWV0aG9kcw0KICAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzZXRSZWRpcmVjdChqYXZhLmxhbmcuU3RyaW5nLCBqYXZhLnV0aWwuTWFwKSI+c2V0UmVkaXJlY3QoU3RyaW5nLCBNYXApPC9hPg0KICAgICAgICAgIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0UmVkaXJlY3QoamF2YS5sYW5nLkNsYXNzLCBqYXZhLnV0aWwuTWFwKSI+c2V0UmVkaXJlY3QoQ2xhc3MsIE1hcCk8L2E+DQogICAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBBZHJpYW4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUzNiI+NTM2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIExpbmsgQ29udHJvbHMgdG8gc3VwcG9ydCBtdWx0aXZhbHVlZCBwYXJhbWV0ZXJzIHRocm91Z2ggdGhlDQogICAgICAgICAgbmV3IEFic3RyYWN0TGluayBtZXRob2RzIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWJzdHJhY3RMaW5rLmh0bWwjZ2V0UGFyYW1ldGVyVmFsdWVzKGphdmEubGFuZy5TdHJpbmcpIj5nZXRQYXJhbWV0ZXJWYWx1ZXMoKTwvYT4NCiAgICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BYnN0cmFjdExpbmsuaHRtbCNzZXRQYXJhbWV0ZXJWYWx1ZXMoamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLlN0cmluZ1tdKSI+c2V0UGFyYW1ldGVyVmFsdWVzKCk8L2E+DQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NTQiPjU1NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBUYWJsZSB0byBzdXBwb3J0IHZlcnkgbGFyZ2UgZGF0YXNldHMgYnkgcHJvbW90aW5nIHRoZSBtZXRob2RzDQogICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9UYWJsZS5odG1sI2dldEZpcnN0Um93KCkiPmdldEZpcnN0Um93KCk8L2E+DQogICAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCNnZXRMYXN0Um93KCkiPmdldExhc3RSb3coKTwvYT4NCiAgICAgICAgICBhcyBwdWJsaWMuIFRoZXNlIG1ldGhvZHMgcHJvdmlkZSB0aGUgbmVjZXNzYXJ5IGluZm9ybWF0aW9uIHRvIG9ubHkNCiAgICAgICAgICByZXRyaWV2ZSB0aGUgZGlzcGxheWVkIHJvd3MNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUwNCI+NTA0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIExpbmtEZWNvcmF0b3IgdG8gc3VwcG9ydCB0YXJnZXQgaWRlbnRpZmllciBwcm9wZXJ0eSBwYXJhbWV0ZXIgbmFtZXMuDQogICAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERlbWV0cmlvcyBLeXJpYWtpcyBhbmQgZml4ZWQgYnkgZml4ZWQgYnkgQWRyaWFuIEEuDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MDAiPjQwMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBQaWNrTGlzdCBtZXRob2RzIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9QaWNrTGlzdC5odG1sI2dldFZhbHVlT2JqZWN0KCkiPmdldFZhbHVlT2JqZWN0KCk8L2E+DQogICAgICAgICAgYW5kIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9QaWNrTGlzdC5odG1sI3NldFZhbHVlT2JqZWN0KGphdmEubGFuZy5PYmplY3QpIj5zZXRWYWx1ZU9iamVjdChPYmplY3QpPC9hPg0KICAgICAgICAgIHRvIGRlbGVnYXRlIHRvIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9QaWNrTGlzdC5odG1sI2dldFNlbGVjdGVkVmFsdWVzKCkiPmdldFNlbGVjdGVkVmFsdWVzKCk8L2E+DQogICAgICAgICAgYW5kIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9QaWNrTGlzdC5odG1sI2FkZFNlbGVjdGVkVmFsdWUoamF2YS5sYW5nLlN0cmluZykiPmFkZFNlbGVjdGVkVmFsdWUoU3RyaW5nKTwvYT4NCiAgICAgICAgICByZXNwZWN0aXZlbHkgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00OTAiPjQ5MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBTcHJpbmcgaW50ZWdyYXRpb24gd2l0aA0KICAgICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvc3ByaW5nL1NwcmluZ0NsaWNrU2VydmxldC5odG1sIj5TcHJpbmdDbGlja1NlcnZsZXQ8L2E+IGFuZA0KICAgICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvc3ByaW5nL1BhZ2VTY29wZVJlc29sdmVyLmh0bWwiPlBhZ2VTY29wZVJlc29sdmVyPC9hPiwNCiAgICAgICAgICBzdXBwb3J0aW5nIFNwcmluZyBpbnN0YW50aWF0ZWQgUGFnZXMgd2l0aCBAQ29tcG9uZW50IGNvbmZpZ3VyYXRpb24NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUzNCI+NTM0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIENvbXByZXNzaW9uU2VydmxldFJlc3BvbnNlV3JhcHBlciBhbmQgQ29tcHJlc3Npb25SZXNwb25zZVN0cmVhbSBjbGFzc2VzIHRvIGhhdmUNCiAgICAgICAgICBwdWJsaWMgdmlzaWJpbGl0eSB0byBlbmFibGUgdXNlIGluIGN1c3RvbSBzZXJ2bGV0IEZpbHRlcnMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvY2xpY2svYnJvd3NlL0NMSy01NDciPjU0NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBNZW51IGNvbnRyb2wgdG8gcmVuZGVyIGF0dHJpYnV0ZSBjbGFzcz0ic2VsZWN0ZWQiIHdoZW4gdGhlIG1lbnUgaXRlbQ0KICAgICAgICAgIGlzIHNlbGVjdGVkLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEZyZWRlcmljIERhb3VkDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2NsaWNrL2Jyb3dzZS9DTEstNTUxIj41NTE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgUGVyZm9ybWFuY2VGaWx0ZXIgdG8gaW1wbGVtZW50IGV4Y2x1ZGUtcGF0aHMgZmlsdGVyaW5nDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2NsaWNrL2Jyb3dzZS9DTEstNDk4Ij40OTg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgSW1wcm92ZWQgWG1sQ29uZmlnU2VydmljZSB0byBzY2FuIGZvciBkZXBsb3lhYmxlIHJlc291cmNlcyBpbnNpZGUgZm9sZGVycw0KICAgICAgICAgIG9uIHRoZSBjbGFzc3BhdGgNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvY2xpY2svYnJvd3NlL0NMSy01NTIiPjU1MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCBDYXllbm5lIERhdGFDb250ZXh0RmlsdGVyLCBpbmNsdWRpbmcgYWRkaW5nIHN1cHBvcnQgZm9yIExpZmVjeWNsZUxpc3RlbmVyDQogICAgICAgICAgcmVnaXN0cmF0aW9uDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NTkiPjU1OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBJbXByb3ZlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0TGluay5odG1sIj5BYnN0cmFjdExpbms8L2E+DQogICAgICAgICAgdG8gYWxsb3cgcmVuZGVyaW5nIG9mIGJvdGggaWNvbiBhbmQgbGFiZWwgaW4gTGluayBjb250cm9scyAoZGVmYXVsdA0KICAgICAgICAgIGJlaGF2aW9yIHJlbmRlcnMgZWl0aGVyIGEgbGFiZWwgb3IgYW4gaWNvbikNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUzNSI+NTM1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEltcHJvdmVkIFBhZ2UgYW5kIENvbnRyb2wgbWVzc2FnZSBoYW5kbGluZyB3aXRoIG51bGwgYXJncy4NCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgV2FybmVySmFuIFZlbGRodWlzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MDAiPjYwMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBGaXhlZCByZXNvdXJjZSBkZXBsb3ltZW50IG9uIEpCb3NzIDUgYW5kIHVwLiBUaGUgc29sdXRpb24gaXMgYmFzZWQgb24NCiAgICAgICAgICB0aGUgd29yayBkb25lIGJ5IHRoZSA8YSBjbGFzcz0iZXh0ZXJuYWwiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vd3d3LnN0cmlwZXNmcmFtZXdvcmsub3JnIj5TdHJpcGVzIEZyYW1ld29yazwvYT4NCiAgICAgICAgICBkZXZlbG9wZXJzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01ODkiPjU4OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBGaXhlZCA8YSBjbGFzcz0iZXh0ZXJuYWwiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vY29kZS5nb29nbGUuY29tL3AvY2xpY2stY2FsZW5kYXIvIj5DbGljayBDYWxlbmRhcjwvYT4NCiAgICAgICAgICBtZW1vcnkgbGVhayBpbiBjYWxlbmRhciBwb3B1cCB3aXRoIHZlcnNpb24gMS4wLjEgcmVsZWFzZWQNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ5OSI+NDk5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIENvbHVtbiBzb3J0aW5nIHRvIHJlY29nbml6ZSBudW1iZXJzIGluc2lkZSBzdHJpbmdzLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBWZW5rYXR0IEd1aGVzYW4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvY2xpY2svYnJvd3NlL0NMSy00ODkiPjQ4OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBGaXhlZCBhIGJ1ZyB3aGVyZSBGaWVsZFNldCB3YXMgbm90IHNldCBhcyB0aGUgcGFyZW50IG9mIGl0cyBjaGlsZCBjb250cm9scy4NCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSmFtZXMgUCBCcm93bg0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9jbGljay9icm93c2UvQ0xLLTQ5NyI+NDk3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCSAgRml4ZWQgRm9ybVRhYmxlIHNvcnRpbmcgYnVnLiBBZGRlZCBGb3JtVGFibGUgc29ydCBtZXRob2RzIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9Gb3JtVGFibGUuaHRtbCNzZXRTb3J0ZWRDb2x1bW4oamF2YS5sYW5nLlN0cmluZykiPnNldFNvcnRlZENvbHVtbjwvYT4sDQogICAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0Zvcm1UYWJsZS5odG1sI3NldFNvcnRlZEFzY2VuZGluZyhib29sZWFuKSI+c2V0U29ydGVkQXNjZW5kaW5nPC9hPiwNCiAgICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvRm9ybVRhYmxlLmh0bWwjc2V0UGFnZU51bWJlcihpbnQpIj5zZXRQYWdlTnVtYmVyPC9hPg0KICAgICAgICAgIGZvciBwcm9ncmFtbWF0aWMgc29ydGluZy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBCZW4gV2FybmVyDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01MjciPjUyNzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBGaXhlZCBhIGJ1ZyBpbiBBdXRvQ29tcGxldGVUZXh0RmllbGQgd2hlcmUgaWYgdGhlIGZpZWxkIHdhcyByZW1vdmVkDQogICAgICAgICAgZnJvbSBhIEZvcm0sIGl0cyBKYXZhU2NyaXB0IHJlc291cmNlcyB3b3VsZCBzdGlsbCBiZSByZW5kZXJlZC4NCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUGF1bCBaYW1taXQNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU0NiI+NTQ2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIGV4dHJhcyA8dHQ+cG9tLnhtbDwvdHQ+IGRlcGVuZGVuY2llcyBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvY2xpY2svYnJvd3NlL0NMSy00OTIiPjQ5MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBGaXhlZCBhIGJ1ZyBpbiBjb250cm9sLmpzIHdoaWNoIGNhdXNlZCB0aGUgYWRkTG9hZEV2ZW50IGV2ZW50IHF1ZXVlIHRvDQogICAgICAgICAgYmUgcmVzZXQgaWYgbXVsdGlwbGUgY29udHJvbC5qcyBzY3JpcHRzIGFyZSBpbXBvcnRlZCBpbiB0aGUgc2FtZSBwYWdlLg0KICAgICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBZHJpYW4NCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUwMyI+NTAzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIEZpeGVkIFBlcmZvcm1hbmNlRmlsdGVyIGFuZCBDb21wcmVzc2lvbkZpbHRlciB0byBwcm9wZXJseSBoYW5kbGUNCiAgICAgICAgICA8dHQ+Jmx0O2pzcDppbmNsdWRlJmd0OzwvdHQ+IHJlcXVlc3RzDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NTciPjU1NzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBGaXhlZCBTdWJtaXRMaW5rIHRvIGNhbGwgRm9ybSBqYXZhc2NyaXB0IHZhbGlkYXRpb24gYmVmb3JlIHN1Ym1pdHRpbmcgZm9ybS4NCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEZpbm4gQm9jaw0KICAgICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTg2Ij41ODY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICAgRml4ZWQgRGF0ZUZpZWxkIG5vdCB0byByZW5kZXIgaGVscCBwcm9wZXJ0eSB0d2ljZS4NCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRmlubiBCb2NrDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NzQiPjU3NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBGaXhlZCBidWcgd2hlcmUgcGFnZXMgaW4gdGhlIGRlZmF1bHQgcGFja2FnZSB3YXMgbm90IGxvYWRlZC4NCiAgICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgVGhpYWdvIFNlbm5hDQogICAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NzUiPjU3NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBGaXhlZCBidWcgaW4gSGliZXJuYXRlRm9ybSB0aGF0IGRpZCBub3QgYXBwbHkgcmVxdWlyZWQgZmllbGQgY29uc3RyYWludHMNCiAgICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTU4MyI+NTgzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIFVwZGF0ZWQgVmVsb2NpdHkgbGlicmFyeSB0byB2ZXJzaW9uIDEuNi4zLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDMuME02Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgICBVcGRhdGVkIENvbW1vbnMgQ29sbGVjdGlvbiBsaWJyYXJ5IHRvIHZlcnNpb24gMy4yLjEuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgIFVwZGF0ZWQgUHJvdG90eXBlLmpzIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjYuMS4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCg0KICA8ZHQ+PGEgbmFtZT0iMi4xLjAtUkMxIj48L2E+VmVyc2lvbiAyLjEuMC1SQzEgKEFwYWNoZSBpbmN1YmF0b3IpIC0gMjggSnVuZSAyMDA5PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIFNlZSB0aGUgcmVsZWFzZSBub3RlcyBmb3IgPGEgaHJlZj0iIzIuMS4wIj4yLjEuMDwvYT4uDQogICAgPC9kaXY+DQogIDwvZGQ+DQoNCiAgPGR0PjxhIG5hbWU9IjIuMC4xIj48L2E+VmVyc2lvbiAyLjAuMSAoQXBhY2hlIGluY3ViYXRvcikgLSAxNSBGZWJydWFyeSAyMDA5PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6IDE1cHg7IG1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIFRoaXMgaXMgb3VyIGZpcnN0IEFwYWNoZSBJbmN1YmF0b3IgcmVsZWFzZSBhbmQgaXMgYmFzZWQgb24gPGEgaHJlZj0iIzEuNS4xIj5DbGljayAxLjUuMTwvYT4uDQogICAgICA8cC8+DQogICAgICBQbGVhc2Ugbm90ZSB0aGF0IGJlY2F1c2Ugb2YgbGljZW5zaW5nIGlzc3VlcywgY2VydGFpbiB0aGlyZC1wYXJ0eQ0KICAgICAgbGlicmFyaWVzIHdlcmUgcmVtb3ZlZCBhbmQgYXJlIGhvc3RlZCBleHRlcm5hbGx5Lg0KICAgIDwvZGl2Pg0KICA8L2RkPg0KDQogIDxkdD48YSBuYW1lPSIxLjUuMSI+PC9hPlZlcnNpb24gMS41LjEgKHByZS1BcGFjaGUpIC0gMjMgSmFudWFyeSAyMDA5PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIFBsZWFzZSBub3RlIHRoYXQgdGhpcyByZWxlYXNlIGlzIHByb3ZpZGVkIG91dHNpZGUgb2YgdGhlIEFTRiBhbmQgaXMgbm90DQogICAgICBlbmRvcnNlZCBvciBhcHByb3ZlZCBieSB0aGUgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24uDQogICAgPC9kaXY+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDogMTVweDsgbWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgVGhlIGZvbGxvd2luZyBpc3N1ZXMgd2VyZSByZXNvbHZlZCBzaW5jZSAxLjU6DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBUdXJraXNoIGxhbmd1YWdlIHN1cHBvcnQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQWxpIE9rLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ3NiI+NDc2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBleGNlcHRpb24gaGFuZGxpbmcgd2hlbiBhIENvbnRyb2wgbmFtZSBpcyBub3QgZGVmaW5lZA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ3MyI+NDczPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBuZXcgY29uc3RydWN0b3JzIHRvIGV4dHJhIGNvbnRyb2xzIHdoaWNoIGFjY2VwdHMgdGhlIDx0dD5zaXplPC90dD4NCiAgICAgICAgYXR0cmlidXRlLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQ2hyaXN0b3BoZSBGb2lyZXQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NzUiPjQ3NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgTWVzc2FnZUZvcm1hdCBzdXBwb3J0IHRvIEZvcm1hdC4gTmV3IG1ldGhvZHMgaW5jbHVkZQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0Zvcm1hdC5odG1sI21lc3NhZ2UoamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLk9iamVjdCkiPm1lc3NhZ2UoU3RyaW5nLCBPYmplY3QpPC9hPg0KICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Gb3JtYXQuaHRtbCNtZXNzYWdlKGphdmEubGFuZy5TdHJpbmcsIGphdmEudXRpbC5MaXN0KSI+bWVzc2FnZShTdHJpbmcsIExpc3QpPC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFl1IEtvYmF5YXNoaQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ3NCI+NDc0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyB0byBDaGVja2JveFRyZWUgdG8gaW1wcm92ZSBjdXN0b21pemF0aW9uLiBUaGUgbmV3IG1ldGhvZHMNCiAgICAgICAgaW5jbHVkZSA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvQ2hlY2tib3hUcmVlLmh0bWwjcmVuZGVyQ2hlY2tib3gob3JnLmFwYWNoZS5jbGljay51dGlsLkh0bWxTdHJpbmdCdWZmZXIsIG9yZy5hcGFjaGUuY2xpY2suZXh0cmFzLnRyZWUuVHJlZU5vZGUpIj5yZW5kZXJDaGVja2JveDwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9DaGVja2JveFRyZWUuaHRtbCNnZXRJbnB1dFR5cGUoKSI+Z2V0SW5wdXRUeXBlPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGNzdiBtaW1lIHR5cGUuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBbHZpbiBUb3duc2VuZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFVSTCByZW5kZXJpbmcgdG8gZW5jb2RlIGFtcGVyc2FuZCBjaGFyYWN0ZXJzLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ4MyI+NDgzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBIaWRkZW5GaWVsZCB0byB3b3JrIHdpdGggamF2YS5zcWwuVGltZXN0YW1wLCBqYXZhLnNxbC5UaW1lIGFuZCBqYXZhLnNxbC5EYXRlLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ4NCI+NDg0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBXZWJhcHBMb2FkZXIgdG8gcmVsb2FkIFZlbG9jaXR5IGdsb2JhbCBtYWNybydzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDY3Ij40Njc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFBhZ2Uuc2V0UmVkaXJlY3QgdG8gY2hlY2sgaWYgcmVkaXJlY3QgcGF0aCBzdGFydHMgd2l0aCBjb250ZXh0IHBhdGguDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBDaHJpc3RvcGhlIEZvaXJldA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2OCI+NDY4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBhIHJlZ3Jlc3Npb24gd2hlbiBtYW51YWxseSBzZXR0aW5nIHRoZSBQYWdlIHBhdGggdG8gYSBKU1AuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTQxIj4xNDE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIERhdGVGaWVsZCdzIEZyZW5jaCB0cmFuc2xhdGlvbi4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFsdmluIFRvd25zZW5kLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KDQogIDxkdD48YSBuYW1lPSIxLjUiPjwvYT5WZXJzaW9uIDEuNSAtIDIgTm92ZW1iZXIgMjAwODwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICBJTVBPUlRBTlQgYmUgc3VyZSB0byByZWFkIHRoZSA8YSBocmVmPSJ1cGdyYWRlLXBhdGguaHRtbCMxLjUiPnVwZ3JhZGUgcGF0aDwvYT4gd2hlbiB1cGdyYWRpbmcgZnJvbSBDbGljayAxLjQgb3IgZWFybGllci4NCiAgICA8L2Rpdj4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOiAxNXB4OyBtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICBUaGUgZm9sbG93aW5nIGlzc3VlcyB3ZXJlIHJlc29sdmVkIHNpbmNlIDEuNSBSQzM6DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBEdXRjaCBsYW5ndWFnZSBzdXBwb3J0LCBjb250cmlidXRlZCBieSBDaHJpc3RvcGhlciBIaWdod2F5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgRm9ybSB0byBwcm9jZXNzIGNvbnRyb2xzIGV2ZW4gaWYgdGhlaXIgbmFtZXMgaXMgbm90IGRlZmluZWQuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDYzIj40NjM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIENvbnRhaW5lclV0aWxzLmNvcHlUbyB3aGVyZSB0aGUgd3JvbmcgZ2V0dGVyIG1ldGhvZCBjb3VsZCBiZSB1c2VkDQogICAgICAgIHdoZW4gYSBkb21haW4gb2JqZWN0IGNvbnRhaW5zIG11bHRpcGxlIG92ZXJsb2FkZWQgZ2V0dGVyIG1ldGhvZHMuIFRoaXMNCiAgICAgICAgaXNzdWUgd2FzIHJhaXNlZCBieSBBbHZpbiBUb3duc2VuZA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2MSI+NDYxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDb2x1bW4gaW50ZXJuYWwgQ29tcGFyYXRvciB3aGljaCBkb2VzIG5vdCB0YWtlIHNvcnQgb3JkZXIgaW50bw0KICAgICAgICBjb25zaWRlcmF0aW9uIGZvciBub24gQ29tcGFyYWJsZSBpbnN0YW5jZXMNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NjIiPjQ2MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgUGFuZWwuZ2V0SWQoKSB0byByZXR1cm4gbnVsbCBpZiBuYW1lIGlzIG5vdCBkZWZpbmVkDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDY0Ij40NjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFZlbG9jaXR5VGVtcGxhdGVTZXJ2aWNlIHRvIGNhdGVyIGZvciBjdXN0b20gZGVmaW5lZCBWZWxvY2l0eSBsb2dnZXJzLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgVmlrcmFtIE5hdGFyYWphbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ2NSI+NDY1PC9hPl0uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQoNCiAgPGR0PjxhIG5hbWU9IjEuNS1SQzMiPjwvYT5WZXJzaW9uIDEuNSBSQzMgLSAxOSBPY3RvYmVyIDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgSU1QT1JUQU5UIGJlIHN1cmUgdG8gcmVhZCB0aGUgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjMS41Ij51cGdyYWRlIHBhdGg8L2E+IHdoZW4gdXBncmFkaW5nIGZyb20gQ2xpY2sgMS40IG9yIGVhcmxpZXIuDQogICAgPC9kaXY+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6IC0yZW07IG1hcmdpbi10b3A6IDEuNWVtOyBtYXJnaW4tYm90dG9tOiAxZW07Ij4NCiAgICAgIE5ldyBleGFtcGxlczoNCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtO21hcmdpbi1ib3R0b206IDJlbSI+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvd2l6YXJkL3dpemFyZC5odG0iPg0KICAgICAgICAgIFdpemFyZCBkZW1vPC9hPiBzaG93cyBob3cgdG8gbGV2ZXJhZ2UgYSA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMwOS5odG1sIj5zdGF0ZWZ1bDwvYT4NCiAgICAgICAgICBwYWdlIGFuZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1BhbmVsLmh0bWwiPlBhbmVsczwvYT4NCiAgICAgICAgICB0byBjcmVhdGUgYSBwcm9jZXNzIGZsb3cuIEVhY2ggU3RlcCBpbiB0aGUgcHJvY2VzcyBpcyByZXByZXNlbnRlZCBieSBhDQogICAgICAgICAgUGFuZWwgd2hpY2ggaXMgbWFuYWdlZCBieSB0aGUgc3RhdGVmdWwgUGFnZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvY29udHJvbC9wb3B1bGF0ZS1vbi1zZWxlY3QuaHRtIj4NCiAgICAgICAgICBQb3B1bGF0ZSBvbiBzZWxlY3Q8L2E+IHNob3dzIGhvdyBpdGVtcyBpbiBvbmUgY29tYm8gYm94IGlzIHBvcHVsYXRlZA0KICAgICAgICAgIGJhc2VkIG9uIHRoZSBzZWxlY3RlZCBpdGVtIGluIGFub3RoZXIgdXNpbmcgSmF2YVNjcmlwdC4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvdGFibGUvZWRpdC1mb3JtLXRhYmxlLmh0bSI+DQogICAgICAgICAgRm9ybVRhYmxlIGRlbW88L2E+IHNob3dzIGhvdyBhIEZvcm1UYWJsZSBjYW4gYmUgdXNlZCB0b2dldGhlciB3aXRoIGFuDQogICAgICAgICAgZXhpc3RpbmcgRm9ybS4NCiAgICAgIDwvbGk+DQogICAgICA8bGk+DQogICAgICAgIDxhIHRhcmdldD0iX2JsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvdHJlZS9wYWdlLWxpbmstdHJlZS1wYWdlLmh0bSI+DQogICAgICAgICAgUGFnZSBsaW5rIHRyZWU8L2E+IHByb3ZpZGVzIGEgZGVtb25zdHJhdGlvbiBvZiB1c2luZyB0aGUgVHJlZSBjb21wb25lbnQNCiAgICAgICAgICB0byBsaW5rIHRvIGRpZmZlcmVudCBwYWdlcy4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDogLTJlbTsgbWFyZ2luLXRvcDogMS41ZW07IG1hcmdpbi1ib3R0b206IDFlbTsiPg0KICAgICAgTmV3IGRvY3VtZW50YXRpb246DQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTttYXJnaW4tYm90dG9tOiAyZW0iPg0KICAgICAgPGxpPg0KICAgICAgICBBZGRlZCBhIGZ1bGwgPGEgaHJlZj0iY2xpY2stZHRkLWV4YW1wbGUuaHRtbCI+Y29uZmlndXJhdGlvbiBleGFtcGxlPC9hPg0KICAgICAgICBjb250YWluaW5nIGFsbCA8dHQ+Y2xpY2sueG1sPC90dD4gPGEgaHJlZj0iY2xpY2stZHRkLmh0bWwiPkRURDwvYT4gZWxlbWVudHMgYW5kIGF0dHJpYnV0ZXMuDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDogMTVweDsgbWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgICAgVGhlIGZvbGxvd2luZyBpc3N1ZXMgd2VyZSByZXNvbHZlZDoNCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtO21hcmdpbi1ib3R0b206IDJlbSI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEZvcm1UYWJsZS5wcm9wZXJ0aWVzIGNvbnRhaW5pbmcgYSBuZXcgcHJvcGVydHkgPHNwYW4gc3R5bGU9ImNvbG9yOm5hdnk7Ij5mb3JtdGFibGUtZXJyb3I8L3NwYW4+Lg0KICAgICAgICBXaGVuIGFkZGluZyBGb3JtVGFibGUgdG8gYW4gZXh0ZXJuYWwgRnJvbSwgdGhlIDxzcGFuIHN0eWxlPSJjb2xvcjpuYXZ5OyI+Zm9ybXRhYmxlLWVycm9yPC9zcGFuPg0KICAgICAgICB3aWxsIGJlIGRpc3BsYXllZCBpZiBvbmUgb2YgdGhlIEZvcm1UYWJsZSBmaWVsZHMgY29udGFpbnMgYW4gZXJyb3IuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZW5hbWVkIENvbnRhaW5lclV0aWxzIG1ldGhvZCBnZXRGaWVsZHMgdG8gZ2V0SW5wdXRGaWVsZHMgd2hpY2ggYmV0dGVyIHJlZmxlY3QgaXRzIGJlaGF2aW9yDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDU3Ij40NTc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFRhYmJlZEZvcm0gYW5kIFRhYmJlZENheWVubmVGb3JtIHRvIGltcG9ydCBKYXZhU2NyaXB0IGFuZCBDU1MgZnJvbSB0aGVpcg0KICAgICAgICBzdXBlcmNsYXNzLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQ2hyaXN0b3BoZSBGb2lyZXQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NTAiPjQ1MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgQ2F5ZW5uZUZvcm0gcGVyZm9ybWluZyBtdWx0aXBsZSBpbnNlcnRzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDUyIj40NTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEZvcm1UYWJsZSBkdXBsaWNhdGUgSFRNTCBpbXBvcnRzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDUzIj40NTM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFhtbENvbmZpZ1NlcnZpY2Ugbm90IGRlcGxveWluZyBKQVIgcmVzb3VyY2VzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDU0Ij40NTQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFBhZ2Uuc2V0UmVkaXJlY3QgdG8gZ3VhcmQgYWdhaW5zdCBkdXBsaWNhdGUgY29udGV4dCBwYXRocy4gVGhpcyBpc3N1ZQ0KICAgICAgICB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBSaWNhcmRvIExlY2hldGENCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NTYiPjQ1NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgQ291bnRyeVNlbGVjdCB0byBleGNsdWRlIGR1cGxpY2F0ZSBjb3VudHJpZXMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZA0KICAgICAgICBhbmQgZml4ZWQgYnkgQ2hyaXN0b3BoZXIgSGlnaHdheQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ1OCI+NDU4PC9hPl0uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxkdD48YSBuYW1lPSIxLjUtUkMyIj48L2E+RGV2ZWxvcG1lbnQgUmVsZWFzZSAtIFZlcnNpb24gMS41IFJDMiAtIDI5IFNlcHRlbWJlciAyMDA4PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbToxZW07Ij4NCiAgICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07bWFyZ2luLWJvdHRvbTogMmVtIj4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIDxzcGFuIHN0eWxlPSJmb250LXdlaWdodDogYm9sZDsgY29sb3I6IG5hdnk7Ij5FbWVyZ2VuY3kgRml4PC9zcGFuPjogQ2xpY2sgdGhyb3dzIEZpbGVOb3RGb3VuZEV4Y2VwdGlvbiB3aGVuIGRlcGxveWluZyBjbGljay1leHRyYXMuamFyDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDQ4Ij40NDg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIENsaWNrIHNob3VsZCBhdXRvbWF0aWNhbGx5IHJlbW92ZSBhIENvbnRyb2wgZnJvbSBpdHMgcGFyZW50IHdoZW4gYWRkaW5nDQogICAgICAgIGl0IHRvIGFub3RoZXIgQ29udGFpbmVyLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ0OSI+NDQ5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCB1dGlsaXR5IG1ldGhvZHMgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwjZW5jb2RlVVJMKGphdmEubGFuZy5PYmplY3QpIj5DbGlja1V0aWxzLmVuY29kZVVSTDwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sI2RlY29kZVVSTChqYXZhLmxhbmcuT2JqZWN0KSI+Q2xpY2tVdGlscy5kZWNvZGVVUkw8L2E+DQogICAgICAgIGZvciBlbmNvZGluZyBhbmQgZGVjb2RpbmcgVVJMJ3MgdXNpbmcgdGhlICJVVEYtOCIgZW5jb2Rpbmcgc2NoZW1lLg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8ZHQ+PGEgbmFtZT0iMS41LVJDMSI+PC9hPkRldmVsb3BtZW50IFJlbGVhc2UgLSBWZXJzaW9uIDEuNSBSQzEgLSAyOCBTZXB0ZW1iZXIgMjAwODwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgICBJTVBPUlRBTlQgYmUgc3VyZSB0byByZWFkIHRoZSA8YSBocmVmPSJ1cGdyYWRlLXBhdGguaHRtbCMxLjUiPnVwZ3JhZGUgcGF0aDwvYT4gd2hlbiB1cGdyYWRpbmcgZnJvbSBDbGljayAxLjQgb3IgZWFybGllci4NCiAgICA8L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlZmFjdG9yZWQgUGFnaW5hdG9yIGludG8gYSBtb3JlIGdlbmVyaWMgaW50ZXJmYWNlIGNhbGxlZA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1JlbmRlcmFibGUuaHRtbCI+UmVuZGVyYWJsZTwvYT4NCiAgICAgICAgd2hpY2ggaXMgaW5kZXBlbmRlbnQgb2YgYW55IHNwZWNpZmljIENvbnRyb2wNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MzQiPjQzNDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkIG5ldyBMaW5rRGVjb3JhdG9yIG1ldGhvZHMgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0xpbmtEZWNvcmF0b3IuaHRtbCNyZW5kZXJBY3Rpb25MaW5rKG9yZy5hcGFjaGUuY2xpY2sudXRpbC5IdG1sU3RyaW5nQnVmZmVyLCBvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuQWJzdHJhY3RMaW5rLCBvcmcuYXBhY2hlLmNsaWNrLkNvbnRleHQsIGphdmEubGFuZy5PYmplY3QsIGphdmEubGFuZy5PYmplY3QpIj5yZW5kZXJBY3Rpb25MaW5rPC9hPg0KICAgICAgICBhbmQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0xpbmtEZWNvcmF0b3IuaHRtbCNyZW5kZXJBY3Rpb25CdXR0b24ob3JnLmFwYWNoZS5jbGljay51dGlsLkh0bWxTdHJpbmdCdWZmZXIsIG9yZy5hcGFjaGUuY2xpY2suY29udHJvbC5BY3Rpb25CdXR0b24sIG9yZy5hcGFjaGUuY2xpY2suQ29udGV4dCwgamF2YS5sYW5nLk9iamVjdCwgamF2YS5sYW5nLk9iamVjdCkiPnJlbmRlckFjdGlvbkJ1dHRvbjwvYT4uDQogICAgICAgIFRoaXMgYWxsb3dzIG1vcmUgZmluZSBncmFpbmVkIGNvbnRyb2wgb3ZlciB0aGUgcmVuZGVyZWQgbGlua3MsIGZvciBleGFtcGxlDQogICAgICAgIG1hbmlwdWxhdGluZyByZXF1ZXN0IHBhcmFtZXRlcnMuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDQ2Ij40NDY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZCBUYWJsZSBSb3cgYXR0cmlidXRlIHN1cHBvcnQgdGhyb3VnaCBuZXcgbWV0aG9kDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCNhZGRSb3dBdHRyaWJ1dGVzKGphdmEudXRpbC5NYXAsIGphdmEubGFuZy5PYmplY3QsIGludCkiPmFkZFJvd0F0dHJpYnV0ZXM8L2E+Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSGFucyBQb28NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MzEiPjQzMTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRmllbGQgZXJyb3IgbWVzc2FnZXMgY2FuIG5vdyBiZSBzcGVjaWZpZWQgcGVyIGluc3RhbmNlLg0KICAgICAgICBTZWUgdGhlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNzZXRFcnJvck1lc3NhZ2UoamF2YS5sYW5nLlN0cmluZykiPkphdmFEb2M8L2E+IGZvciBtb3JlIGRldGFpbHMuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgUmljYXJkbyBMZWNoZXRhDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDMzIj40MzM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG5ldyB1dGlsaXR5IG1ldGhvZHMNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Db250YWluZXJVdGlscy5odG1sI2NvcHlDb250YWluZXJUb09iamVjdChvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuQ29udGFpbmVyLCBqYXZhLmxhbmcuT2JqZWN0LCBqYXZhLnV0aWwuTGlzdCkiPmNvcHlDb250YWluZXJUb09iamVjdDwvYT4NCiAgICAgICAgYW5kIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ29udGFpbmVyVXRpbHMuaHRtbCNjb3B5Q29udGFpbmVyVG9PYmplY3Qob3JnLmFwYWNoZS5jbGljay5jb250cm9sLkNvbnRhaW5lciwgamF2YS5sYW5nLk9iamVjdCwgamF2YS51dGlsLkxpc3QpIj5jb3B5T2JqZWN0VG9Db250YWluZXI8L2E+DQogICAgICAgIHRvIHNlbGVjdGl2ZWx5IGV4Y2x1ZGUgb3IgaW5jbHVkZSBmb3JtIGZpZWxkcyB3aGVuIHBvcHVsYXRpbmcgZG9tYWluIG9iamVjdHMuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBLaGFsZWYgQmVzc2FpaA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ0MCI+NDQwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBFbmNhcHN1bGF0ZSBjb252ZXJzaW9uIGxvZ2ljIG9mIHRlbXBsYXRlIGV4dGVuc2lvbnMgaW5zaWRlDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzZXRSZWRpcmVjdChqYXZhLmxhbmcuU3RyaW5nKSI+UGFnZS5zZXRSZWRpcmVjdChqYXZhLmxhbmcuU3RyaW5nKTwvYT4NCiAgICAgICAgd2hpY2ggYWxsb3dzIG9uZSB0byBvdmVycmlkZSBvciBvdmVybG9hZCB0aGUgZGVmYXVsdCBiZWhhdmlvci4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEJhbGxhcmQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MjkiPjQyOTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIFRhYmxlIHNvIHRoYXQgc3ViY2xhc3NlcyBjYW4gc3BlY2lmeSBhIGRpZmZlcmVudA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1RhYmxlLmh0bWwjY29udHJvbExpbmsiPmNvbnRyb2xMaW5rPC9hPg0KICAgICAgICBpbXBsZW1lbnRhdGlvbiBieSBvdmVycmlkaW5nIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCNnZXRDb250cm9sTGluaygpIj5nZXRDb250cm9sTGluaygpPC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBSaWNhcmRvIExlY2hldGENCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NDIiPjQ0MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9DbGlja1V0aWxzLmh0bWwjdG9MYWJlbChqYXZhLmxhbmcuU3RyaW5nKSI+Q2xpY2tVdGlscy50b0xhYmVsPC9hPiB0byByZXR1cm4gZW1wdHkgU3RyaW5nICgiIikgaWYgYXJndW1lbnQgaXMgbnVsbA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ0MSI+NDQxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBEYXRlRmllbGQgdG8gcmV0dXJuIGEgY2FjaGVkIERhdGUgcmVwcmVzZW50YXRpb24gb24gc3Vic2VxdWVudCByZXRyaWV2YWxzLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgVG9yZSBIYWxzZXQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMTYiPjMxNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgUmVnZXhGaWVsZCB2YWxpZGF0aW9uIHRvIGlnbm9yZSBlbXB0eSB2YWx1ZXMuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBNdXphZmZlciBPemFrY2ENCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MzYiPjQzNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgVGFiYmVkUGFuZWwgdG8gdHJpZ2dlciB0aGUgcmVnaXN0ZXJlZCB0YWIgbGlzdGVuZXIuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBNYXJjZWxvIEdyYXNzaSBGcmFuY28gTWVsZ2Hnby4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MzIiPjQzMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgcmVkaXJlY3QgYW5kIGZvcndhcmQgdG8gSlNQIHRlbXBsYXRlcy4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MzUiPjQzNTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgSHRtbEZpZWxkU2V0IHRvIHByb3Blcmx5IGNsb3NlIHRoZSBmaWVsZHNldCBlbmQgdGFnLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgR2lsYmVydG8gQy4gQW5kcmFkZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQyNyI+NDI3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBBYnN0cmFjdENvbnRhaW5lckZpZWxkIG5vdCB0byBiaW5kIGl0cyByZXF1ZXN0IHBhcmFtZXRlci4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEdpbGJlcnRvIEMuIEFuZHJhZGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MjgiPjQyODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgQ29sdW1uIHdoaWNoIGV4cG9zZWQgaXRzIGludGVybmFsIENvbXBhcmF0b3IgYXMgcHVibGljIEFQSQ0KICAgICAgICB0aHJvdWdoIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQ29sdW1uLmh0bWwjc2V0Q29tcGFyYXRvcihqYXZhLnV0aWwuQ29tcGFyYXRvcikiPkNvbHVtbi5zZXRDb21wYXJhdG9yKENvbXBhcmF0b3IpPC9hPiwNCiAgICAgICAgaW5zdGVhZCBvZiBqYXZhLnV0aWwuQ29tcGFyYXRvci4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MzAiPjQzMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgTGlua0RlY29yYXRvciBub3QgdG8gYWRkIFRhYmxlIHBhcmFtZXRlcnMgdG8gUGFnZUxpbmssIGFzIGl0IGlzIHJlZHVuZGFudC4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEpvZWwgU2NobWlkdA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3MCI+MjcwPC9hPl0uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxkdD48YSBuYW1lPSIxLjUtTTMiPjwvYT5EZXZlbG9wbWVudCBSZWxlYXNlIC0gVmVyc2lvbiAxLjUgTTMgLSAxNyBBdWd1c3QgMjAwODwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgIElNUE9SVEFOVCBiZSBzdXJlIHRvIHJlYWQgdGhlIDxhIGhyZWY9InVwZ3JhZGUtcGF0aC5odG1sIzEuNSI+dXBncmFkZSBwYXRoPC9hPiB3aGVuIHVwZ3JhZGluZyBmcm9tIENsaWNrIDEuNCBvciBlYXJsaWVyLg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTWFqb3IgcmVmYWN0b3JpbmcgdG8gaW1wcm92ZSBiYWNrd2FyZCBjb21wYXRpYmlsaXR5IGFuZCB1cGdyYWRlIHBhdGguDQogICAgICAgIFRoaXMgaW5jbHVkZXMgcmVtb3ZpbmcgQmFzaWNGb3JtIHdoaWNoIHdhcyBpbmNsdWRlZCBpbiAxLjUtTTEgYW5kIGFkZGluZw0KICAgICAgICBuZXcgQ29udHJvbHMgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0h0bWxGb3JtLmh0bWwiPkh0bWxGb3JtPC9hPg0KICAgICAgICBhbmQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0h0bWxGaWVsZFNldC5odG1sIj5IdG1sRmllbGRTZXQ8L2E+Lg0KICAgICAgICBZb3UgY2FuIGZpbmQgYW4gZXhhbXBsZSBvZiBIdG1sRm9ybSBpbiBhY3Rpb24gPGEgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9jbGljay5hdm9rYS5jb20vY2xpY2stZXhhbXBsZXMvZm9ybS9jb250YWN0LWRldGFpbHMuaHRtIj5oZXJlPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG11bHRpcGxlIHBhZ2UgcGFja2FnZSBkZWZpbml0aW9ucyBpbiBjbGljay54bWwgY29uZmlndXJhdGlvbi4NCiAgICAgICAgU2VlIHRoZSBjb25maWd1cmF0aW9uIHRvcGljIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAyLmh0bWwjYXBwbGljYXRpb24tbXVsdGlwbGUtcGFja2FnZXMiPk11bHRpcGxlIFBhZ2VzIFBhY2thZ2VzPC9hPg0KICAgICAgICBmb3IgbW9yZSBkZXRhaWxzLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUmljYXJkbyBSLiBMZWNoZXRhDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzI4Ij4zMjg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGNvbmZpZ3VyYWJsZSB0YWJsZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1RhYmxlUGFnaW5hdG9yLmh0bWwiPlBhZ2luYXRvcjwvYT4gc3VwcG9ydA0KICAgICAgICBhbmQgYW4gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL1RhYmxlSW5saW5lUGFnaW5hdG9yLmh0bWwiPklubGluZVBhZ2luYXRvcjwvYT4uDQogICAgICAgIEEgbmV3IDxhIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vY2xpY2suYXZva2EuY29tL2NsaWNrLWV4YW1wbGVzL3RhYmxlL3RhYmxlLXBhZ2luYXRvci5odG0iPmV4YW1wbGU8L2E+DQogICAgICAgIHNob3dzIHRoZSBkaWZmZXJlbnQgUGFnaW5hdG9yIG9wdGlvbnMgYXZhaWxhYmxlLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgR3VzdGF2IFdlYmVyDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzkwIj4zOTA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHJlYWRvbmx5IGFuZCBkaXNhYmxlZCBzdXBwb3J0IHRvIEZpZWxkU2V0LiBJZiBlbmFibGVkIEZpZWxkcyBjb250YWluZWQNCiAgICAgICAgaW4gRmllbGRTZXQgd2lsbCBiZSBkaXNhYmxlZCBvciBtYWRlIHJlYWRvbmx5Lg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQyMyI+NDIzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBUYWJsZSBmb290ZXIgcmVuZGVyaW5nIHN1cHBvcnQsIHNvIHRoYXQgY29sdW1uIHRvdGFscyBjYW4gYmUgcmVuZGVyZWQgaW4gYSB0YWJsZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQyNSI+NDI1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBUYWJsZSByZW5kZXJpbmcgcGVyZm9ybWFuY2UgaW4gdGhlIG9yZGVyIG9mIDI1LTQ1JS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIHJlbmRlcmluZyBwZXJmb3JtYW5jZSBieSBjYWNoaW5nIHRoZSBDbGlja1V0aWxzDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sI2dldFJlc291cmNlVmVyc2lvbkluZGljYXRvcihvcmcuYXBhY2hlLmNsaWNrLkNvbnRleHQpIj5yZXNvdXJjZSB2ZXJzaW9uIGluZGljYXRvcjwvYT4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MTIiPjQxMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgUGFnZSBhbmQgUGFnZUltcG9ydHMgdG8gYWxsb3cgYSBQYWdlcyB0byBvcHRpbWl6ZSB0aGVpciBIVE1MIGltcG9ydHMuDQogICAgICAgIFBsZWFzZSBzZWUgQ2xpY2sgRXhhbXBsZXMgZm9yIGEgZGVtb25zdHJhdGlvbg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM2MyI+MzYzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBpc3N1ZSB3aGVyZSBTZWxlY3QgdmFsaWRhdGlvbiBjYW4gdGhyb3cgQ2xhc3NDYXN0RXhjZXB0aW9uDQogICAgICAgIHdoZW4gb3B0aW9uIGxpc3QgY29udGFpbnMgYW4gT3B0aW9uR3JvdXAuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZXIgYnkgQ2hyaXN0b3BoZSBGb2lyZXQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNzQiPjM3NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgaXNzdWUgd2hlcmUgQ29udGFpbmVyIGNhbiBiZSBhZGRlZCB0byBpdHNlbGYuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZXIgYnkgSGFycnkgV2lzc2lhaw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQxNCI+NDE0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBQYWdlIHNlcmlhbGl6YXRpb24gaXNzdWVzIHdpdGggbm9uIHNlcmlhbGl6YWJsZSBGb3JtYXQgYW5kIFBhZ2VJbXBvcnQgb2JqZWN0cy4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllciBieSBBbGV4ZWkgU29rb2xvdg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQxNiI+NDE2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBpc3N1ZSB3aGVyZSBDYXllbm5lRm9ybSBjbGVhclZhbHVlcygpIHdhcyBoaWRkZW4gZGF0YSBvYmplY3QgY2xhc3NuYW1lLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVyIGJ5IFdpc2tpbmcgSnUgWXUgV3UNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MTciPjQxNzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgaXNzdWUgd2hlcmUgVGFiYmVkUGFuZWwgd2FzIGludm9raW5nIHRoZSBhY3RpdmVQYW5lbCdzIG9uSW5pdCgpIG1ldGhvZCB0d2ljZS4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllciBieSBXaXNraW5nIEp1IFl1IFd1DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDIwIj40MjA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPGR0PjxhIG5hbWU9IjEuNS1NMiI+PC9hPkRldmVsb3BtZW50IFJlbGVhc2UgLSBWZXJzaW9uIDEuNSBNMiAtIDIwIEp1bHkgMjAwODwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MWVtOyI+DQogICAgSU1QT1JUQU5UIGJlIHN1cmUgdG8gcmVhZCB0aGUgPGEgaHJlZj0idXBncmFkZS1wYXRoLmh0bWwjMS41Ij51cGdyYWRlIHBhdGg8L2E+IHdoZW4gdXBncmFkaW5nIGZyb20gQ2xpY2sgMS40IG9yIGVhcmxpZXIuDQogICAgPHAvPg0KICAgIENsaWNrIDEuNSBNMiBpbnRyb2R1Y2VkIG1ham9yIGVuaGFuY2VtZW50cyB0byBDb250cm9sIGxpc3RlbmVyIHN1cHBvcnQuDQogICAgPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBOZXcgQ29udHJvbCBsaXN0ZW5lciBzdXBwb3J0IHRocm91Z2ggdGhlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0FjdGlvbkxpc3RlbmVyLmh0bWwiPkFjdGlvbkxpc3RlbmVyPC9hPiBpbnRlcmZhY2UuDQogICAgICAgIFRoaXMgY29udHJvbCBsaXN0ZW5lciBzdHlsZSBwcm92aWRlcyBjb21waWxlIHRpbWUgc2FmZXR5IGFuZCBzdXBwb3J0cyBjb2RlIHJlZmFjdG9yaW5nIHRvb2xzLg0KDQogICAgICA8cHJlIGNsYXNzPSJwcmV0dHlwcmludCI+DQpwdWJsaWMgY2xhc3MgTXlQYWdlIGV4dGVuZHMgUGFnZSB7DQoNCiAgICBwdWJsaWMgdm9pZCBvbkluaXQoKSB7DQogICAgICAgIFN1Ym1pdCBzdWJtaXQgPSBuZXcgU3VibWl0KCJzdWJtaXQiKTsNCg0KICAgICAgICBzdWJtaXQuc2V0QWN0aW9uTGlzdGVuZXIobmV3IEFjdGlvbkxpc3RlbmVyKCkgew0KICAgICAgICAgICAgcHVibGljIGJvb2xlYW4gb25BY3Rpb24oQ29udHJvbCBzb3VyY2UpIHsNCiAgICAgICAgICAgICAgICAvLyBQZXJmb3JtIHN1Ym1pdCBhY3Rpb24gYW5kIHJldHVybiB0cnVlIHRvIGNvbnRpbnVlIHByb2Nlc3NpbmcNCiAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsNCiAgICAgICAgICAgIH0NCiAgICAgICAgfSk7DQogICAgfQ0KfSA8L3ByZT4NCiAgICAgIE5vdGUgdGhhdCB0aGUgc291cmNlIENvbnRyb2wgaXMgcGFzc2VkIGluIGFzIGFuIGFyZ3VtZW50IHRvIHRoZSBvbkFjdGlvbiBtZXRob2QuDQogICAgICBGb3IgdmVyeSBjb21wbGV4IHNjZW5hcmlvcyBpdCBpcyB1c2VmdWwgdG8ga25vdyB3aGljaCBDb250cm9sIHRyaWdnZXJlZCB0aGUgZXZlbnQNCiAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzY5Ij4zNjk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEludHJvZHVjZSBhIHR3byBwaGFzZSBsaXN0ZW5lciBkaXNwYXRjaCBtZWNoYW5pc20uIER1cmluZyB0aGUgb25Qcm9jZXNzIGV2ZW50LA0KICAgICAgICBDb250cm9sIGxpc3RlbmVycyB3aWxsIGJlIHJlZ2lzdGVyZWQgb24gdGhlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0FjdGlvbkV2ZW50RGlzcGF0Y2hlci5odG1sIj5BY3Rpb25FdmVudERpc3BhdGNoZXI8L2E+DQogICAgICAgIGFuZCB0cmlnZ2VyZWQgYWZ0ZXIgdGhlIG9uUHJvY2VzcyBldmVudCBmaW5pc2guIFRoZSBuZXQgZWZmZWN0IG9mIHRoaXMgY2hhbmdlDQogICAgICAgIGlzIHRoYXQgd2hlbiBDb250cm9sIGxpc3RlbmVycyBhcmUgdHJpZ2dlcmVkLCBhbGwgcmVxdWVzdCB2YWx1ZXMgaGF2ZSBiZWVuIGJvdW5kIHRvIENvbnRyb2xzLA0KICAgICAgICBhbmQgY2FuIHNhZmVseSBiZSByZWZlcnJlZCB0byBmcm9tIHRoZSBsaXN0ZW5lciBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM2NSI+MzY1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBidXR0b24gc3VwcG9ydCB0byBGaWVsZFNldCwgc28gdGhhdCBidXR0b25zIGNhbiBiZSByZW5kZXJlZCBpbnNpZGUNCiAgICAgICAgRmllbGRTZXRzLiBUaGlzIGNoYW5nZSBoYXMgYmVlbiBlbmFibGVkIGJ5IHR3byBwaGFzZSBwcm9jZXNzaW5nIHdoaWNoDQogICAgICAgIGVuc3VyZXMgYWxsIEZpZWxkU2V0IGZpZWxkcyBhcmUgcHJvY2Vzc2VkIGJlZm9yZSBidXR0b24gbGlzdGVuZXJzIGFyZSBpbnZva2VkDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDAxIj40MDE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgIDwvdWw+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPg0KICAgIFRoZSBmb2xsb3dpbmcgaXMgYSBsaXN0IG9mIGVuaGFuY2VtZW50cyBhbmQgYnVncyBmaXhlczoNCiAgICA8L2Rpdj4NCgk8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGEgbmV3IDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9QYWdlQnV0dG9uLmh0bWwiPlBhZ2VCdXR0b248L2E+IGNvbnRyb2wNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zOTIiPjM5MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW50cm9kdWNlZCBhIG5ldyByZXNvdXJjZSBkZXBsb3ltZW50IHN0cmF0ZWd5IGZvciA8ZW0+SmFyczwvZW0+IGNvbnRhaW5pbmcNCiAgICAgICAgUGFnZSBhbmQgQ29udHJvbCByZXNvdXJjZXMuIFdoZW4gQ2xpY2sgc3RhcnRzIHVwLCBpdCBzY2FucyBlYWNoIEphciBmb3VuZA0KICAgICAgICBpbiB0aGUgd2ViIGxpYiBmb2xkZXIgKHdlYmFwcC9XRUItSU5GL2xpYikgZm9yIGVudHJpZXMgc3RhcnRpbmcgd2l0aCAnTUVUQS1JTkYvd2ViLycuDQogICAgICAgIEFsbCBmaWxlcyBmb3VuZCB1bmRlciAnTUVUQS1JTkYvd2ViLycgd2lsbCBiZSBjb3BpZWQgdmVyYmF0aW0gdG8gdGhlIHdlYg0KICAgICAgICBhcHBsaWNhdGlvbiBmb2xkZXIuDQogICAgICAgIDxwLz4NCiAgICAgICAgU2VlIHRoZSBzZWN0aW9uIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAzLmh0bWwjZGVwbG95aW5nLWN1c3RvbS1yZXNvdXJjZXMiPkRlcGxveWluZyBDdXN0b20gUmVzb3VyY2VzPC9hPg0KICAgICAgICBmb3IgbW9yZSBkZXRhaWwuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzkzIj4zOTM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZCBuZXcgbWV0aG9kIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9DaGVja2JveFRyZWUuaHRtbCNzZXRTZWxlY3RDaGlsZE5vZGVzKGJvb2xlYW4pIj5DaGVja2JveFRyZWUuc2V0U2VsZWN0Q2hpbGROb2RlczwvYT4NCiAgICAgICAgdGhhdCBlbmFibGVzIHNlbGVjdGluZyBjaGlsZCBub2RlcyB3aGVuIHBhcmVudCBpcyBzZWxlY3RlZC4gVGhpcyBmZWF0dXJlDQogICAgICAgIG9ubHkgd29ya3MgaWYgdGhlIFRyZWUncyA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZS5odG1sI3NldEphdmFzY3JpcHRFbmFibGVkKGJvb2xlYW4pIj5KYXZhc2NyaXB0PC9hPg0KICAgICAgICBzdXBwb3J0IGlzIGVuYWJsZWQuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjA5Ij4yMDk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHByb3BlcnR5IGZpbGVzIHdpdGggdHJhbnNsYXRpb24gZm9yIHRoZSBSb21hbmlhbiBsYW5ndWFnZS4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBNYXJpdXMgUGV0cnVzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzYxIj4zNjE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZCB3aWR0aCBzdXBwb3J0IHRvIFRhYmJlZFBhbmVsIGNvbnRyb2wNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNzYiPjM3NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkIHN0YXRpYyBtZXRob2QgQ29udGV4dC5oYXNUaHJlYWRMb2NhbENvbnRleHQoKS4NCiAgICAgICAgVXNlZnVsIGZvciBjaGVja2luZyBpZiBhIENvbnRleHQgaXMgYXZhaWxhYmxlIG9uIHRoZSBDb250ZXh0IHN0YWNrDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzgyIj4zODI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZCBDbGlja1V0aWxzIGF1dG9Qb3N0UmVkaXJlY3QoKSBtZXRob2QgdG8gc3VwcG9ydA0KICAgICAgICA8YSBjbGFzcz0iZXh0ZXJuYWwiIHRhcmdldD0iX2JsYW5rIiBocmVmPSJodHRwOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL1NBTUwiPlNBTUw8L2E+DQogICAgICAgIGludGVncmF0aW9uDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzk4Ij4zOTg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCVVwZGF0ZWQgQ29udGFpbmVyIHJlbmFtaW5nIG1ldGhvZCBDb250YWluZXIuYWRkKGludCwgQ29udHJvbCkgdG8gQ29udGFpbmVyLmluc2VydChDb250cm9sLCBpbnQpDQoJCXRvIGJldHRlciByZWZsZWN0IHRoZSBpbnRlbnRpb24NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zODEiPjM4MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlIEZvcm0gdG8gdXNlIGNvbnRyb2wgbWVzc2FnZSBidW5kbGVzIGZvciBsYWJlbCByZXF1aXJlZCBwcmVmaXgvc3VmZml4DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzgzIj4zODM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZSBIdG1sU3RyaW5nQnVmZmVyIHRvIHN1cHBvcnQgbWV0aG9kIGNoYWluaW5nLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGVtZXRyaW9zIEt5cmlha2lzDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzk2Ij4zOTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgTWVudSBzbyB0aGF0IGl0IGlzIG5vdyBvbmx5IGNhY2hlZCBpbiBwcm9kdWN0aW9uIG9yIHByb2ZpbGUgbW9kZXMuDQogICAgICAgIEluIG90aGVyIGRldmVsb3BtZW50IG1vZGVzLCBjaGFuZ2VzIHRvIG1lbnUueG1sIGlzIHNlZW4gaW1tZWRpYXRlbHkuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDA4Ij40MDg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQWJzdHJhY3RDb250YWluZXJGaWVsZCBjb250cm9sIG1vdmluZyBpdCB0byBDbGljayBFeHRyYXMuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDEwIj40MTA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFRhYmJlZFBhbmVsIGJ1ZyB3aGVyZWJ5IGluYWN0aXZlIHBhbmVsIEhUTUwgaW1wb3J0cyBhcmUgaW5jbHVkZWQgaW4gcGFnZQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM2NiI+MzY2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBGaWVsZFNldCByZWN1cnNpdmUgcmVtb3ZlIGJ1Zw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM2NyI+MzY3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBidWcgd2hlbiBtYW51YWxseSBpbnZhbGlkYXRpbmcgSHR0cFNlc3Npb24NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNzEiPjM3MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgUHJvcGVydHlTZWxlY3QgYWRkIG9yZGVyaW5nIHRvIHF1ZXJ5IGJ1Zw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM3MiI+MzcyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBtZXNzYWdlIHByb3BlcnRpZXMgdG8gcmVzb2x2ZSBhbGwgcGFyZW50IG1lc3NhZ2VzDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzczIj4zNzM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIExhYmVscyBub3QgcmVuZGVyaW5nIGluIGEgRmllbGRTZXQgYnVnDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzc3Ij4zNzc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIEZvcm0gcmVtb3ZlRmllbGQgdGhyb3dzIElsbGVnYWxBcmd1bWVudEV4Y2VwdGlvbiBidWcNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNzgiPjM3ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRmllbGRTZXQgcmVzdG9yaW5nIEZpZWxkU2V0IGFiaWxpdHkgdG8gc2V0IG51bWJlciBvZiB0YWJsZSBjb2x1bW5zDQoJCXRoZSBGaWVsZFNldCBpcyByZW5kZXJlZCB3aXRoDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzc5Ij4zNzk8L2E+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+DQogICBBIG5ldyA8YSBocmVmPSJjbGljay1vbmxpbmUuaHRtbCNwb3dlcmVkIj5Qb3dlcmVkIGJ5IENsaWNrPC9hPiBzZWN0aW9uIHdhcyBhZGRlZC4NCiAgIElmIHlvdSB3YW50IHRvIGVubGlzdCB5b3VyIHNpdGUsIHBsZWFzZSBzZW5kIGEgbWFpbCB0byBvbmUgb2Ygb3VyDQogICA8YSBocmVmPSJjbGljay1vbmxpbmUuaHRtbCNtYWlsaW5nLWxpc3RzIj5NYWlsaW5nIExpc3RzPC9hPiBvciBkaXJlY3RseSB0byAic2Fib2IxIGF0IGdtYWlsLmNvbSIuDQogICA8cC8+DQogICBUaGUgZm9sbG93aW5nIGlzIGEgbGlzdCBvZiBlbmhhbmNlbWVudHMgYW5kIGJ1Z3MgZml4ZXM6DQogIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgQWRkZWQgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL3d3dy5mcmVlbWFya2VyLm9yZyI+RnJlZW1hcmtlcjwvYT4gc3VwcG9ydCBhcyBhbg0KCSAgICBhbHRlcm5hdGl2ZSB0ZW1wbGF0aW5nIGVuZ2luZSB0byBWZWxvY2l0eSwgd2l0aCBuZXcNCgkgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9zZXJ2aWNlL0ZyZWVtYXJrZXJUZW1wbGF0ZVNlcnZpY2UuaHRtbCI+RnJlZW1hcmtlclRlbXBsYXRlU2VydmljZTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCSAgICBBZGRlZCBhIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9Db3VudHJ5U2VsZWN0Lmh0bWwiPkNvdW50cnkgU2VsZWN0PC9hPg0KCSAgICBjb250cm9sIGJhc2VkIG9uIHRoZSBKREsncyBvd24gYnVpbHQgaW4gQ291bnRyeS9Mb2NhbGUgc3VwcG9ydC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIEFkZGVkIGEgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL1ZpcnR1YWxLZXlib2FyZC5odG1sIj5WaXJ0dWFsIEtleWJvYXJkPC9hPg0KCSAgICBjb250cm9sIHVzaW5nIDxhIGhyZWY9Imh0dHA6Ly93d3cuZ3JleXd5dmVybi5jb20vY29kZS9qcy9rZXlib2FyZC5odG1sIj5HcmV5V3l2ZXJuPC9hPiBKYXZhU2NyaXB0IGxpYnJhcnkuDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCSAgICBBZGRlZCBzdXBwb3J0IGZvciBzZXR0aW5nIEZvcm0NCgkgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjZ2V0QWN0aW9uVVJMKCkiPmFjdGlvbjwvYT4NCgkgICAgVVJMIGF0dHJpYnV0ZS4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEVyZGVtIEd1bmF5DQoJICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzE5Ij4zMTk8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIEFkZGVkIHN1cHBvcnQgZm9yIFBhZ2UgSFRNTAlpbXBvcnRzIHdpdGggYSBuZXcgPHR0PmdldEh0bWxJbXBvcnRzKCk8L3R0Pg0KCSAgICBtZXRob2QuIFRoaXMgZW5hYmxlcyBQYWdlcyB0byBwcm9ncmFtbWF0aWNhbGx5IGRlZmluZSBIVE1MIGltcG9ydHMgd2hpY2gNCgkgICAgd2lsbCBiZSBpbmNsdWRlZCBpbiBhIGJvcmRlciB0ZW1wbGF0ZSB1c2luZyB0aGUgUGFnZUltcG9ydHMgb2JqZWN0Lg0KCSAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCgkgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMjkiPjMyOTwvYT5dLg0KCSAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkIFBhZ2UgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI3NldFRlbXBsYXRlKGphdmEubGFuZy5TdHJpbmcpIj5zZXRUZW1wbGF0ZShTdHJpbmcpPC9hPg0KICAgICAgICBtZXRob2QgdG8gZW5hYmxlIGR5bmFtaWMgY2hhbmdpbmcgb2YgYSBwYWdlIGJvcmRlciB0ZW1wbGF0ZS4gVGhpcyBpc3N1ZQ0KICAgICAgICB3YXMgcmFpc2VkIGJ5IEh1eSBEbw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM1MyI+MzUzPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzZXRQYXRoKGphdmEubGFuZy5TdHJpbmcpIj5QYWdlLnNldFBhdGg8L2E+IHRvIGhhbmRsZSBKU1AgcmVzb3VyY2VzLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEh1eSBEby4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNDEiPjE0MTwvYT5dLg0KCSAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgSGliZXJuYXRlIEFubm90YXRpb25Db25maWd1cmF0aW9uLiBUaGlzIGlzc3VlIHdhcyBmaXhlZCBieSBKZWFuLUZyYW5jb2lzLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM1NSI+MzU1PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXByb3ZlZCBGaWxlVXBsb2FkIHN1cHBvcnQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMjYiPjMyNjwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wcm92ZSBGaWxlIFVwbG9hZCBzdXBwb3J0IHdpdGggbmV3IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvRmlsZVVwbG9hZFNlcnZpY2UuaHRtbCI+RmlsZVVwbG9hZFNlcnZpY2U8L2E+IGNsYXNzLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyNiI+MzI2PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBQcm9wZXJ0eVNlbGVjdCB3aGljaCBpcyBub3QgcmVzZXQgdG8gb3JpZ2luYWwgdmFsdWUuIFRoaXMgaXMgd2FzIHJhaXNlZCBieSBUb3JlIEhhbHNldA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxNyI+MzE3PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDYXllbm5lIDMuME0zIERhdGFPYmplY3RVdGlscyBpc3N1ZSBpbiBDYXllbm5lRm9ybSB3aGVuIHVzaW5nIEpESyAxLjUuDQogICAgICAgIEFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9DYXllbm5lVXRpbHMuaHRtbCI+Q2F5ZW5uZVV0aWxzPC9hPiBoZWxwZXIgY2xhc3MNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNDIiPjM0MjwvYT5dLg0KCSAgPC9saT4NCiAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgIFVwZ3JhZGVkIHRoZSBmb2xsb3dpbmcgbGlicmFyaWVzOg0KICAgICA8dWwgc3R5bGU9Im1hcmdpbi10b3A6MWVtOyI+DQogICAgICAgPGxpPmNvbW1vbnMtbGFuZyAyLjEgLT4gY29tbW9ucy1pbyAyLjQ8L2xpPg0KICAgICAgIDxsaT5jb21tb25zLWlvIDEuMyAtPiBjb21tb25zLWlvIDEuNDwvbGk+DQogICAgICAgPGxpPmNvbW1vbnMtZmlsZXVwbG9hZCAxLjIgLT4gY29tbW9ucy1maWxldXBsb2FkIDEuMi4xPC9saT4NCiAgICAgICA8bGk+SGliZXJuYXRlIDMuMS4zIC0+IEhpYmVybmF0ZSAzLjIuNjwvbGk+DQogICAgICAgPGxpPlNwcmluZyAxLjIuOSAtPiBTcHJpbmcgMi41LjQ8L2xpPg0KICAgICA8L3VsPg0KICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+UmVtb3ZlZCBzdXBwb3J0IGZvciBDYXllbm5lIDEuMi54LjwvbGk+DQogIAk8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD48YSBuYW1lPSIxLjQuMiI+PC9hPlZlcnNpb24gMS40LjIgLSAxMiBBcHJpbCAyMDA4PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRXhjbHVkZVBhZ2Ugc2hvdWxkIGJlIGEgcHVibGljIGNsYXNzDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQ2Ij4zNDY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIE1hdmVuIGFydGlmYWN0cyBwYWNrYWdpbmcNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNDgiPjM0ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgc2xpZ2h0IHBlcmZvcm1hbmNlIGRlZ3JhZGF0aW9uDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQ5Ij4zNDk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgUGFnZUxpbmsgdG8gY2hhbmdlIGV4dGVuc2lvbiA8dHQ+anNwPC90dD4gdG8gPHR0Pmh0bTwvdHQ+DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzUyIj4zNTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgRGF0ZUZpZWxkIGFuZCBDaGFydEZpZWxkcyB0byBpbmNsdWRlIHRoZSBqYXZhc2NyaXB0IDx0dD5jb250cm9sLmpzPC90dD4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNTQiPjM1NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBEYXRlRmllbGQgd2hpY2ggcHJvZHVjZWQgZHVwbGljYXRlIHN0eWxlc2hlZXQgbGlua3MuDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzU2Ij4zNTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPGR0PjxhIG5hbWU9IjEuNC4xIj48L2E+VmVyc2lvbiAxLjQuMSAtIDMwIE1hcmNoIDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjFlbTsiPiBEZXZlbG9wZXINCiAgICA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL3NhYm9iLyI+Qm9iIFNjaGVsbGluazwvYT4NCiAgICBhY2NlcHRzIG5ldyBQcm9qZWN0IExlYWRlciByb2xlIGZvciB0aGUgQ2xpY2sgcHJvamVjdC48YnIvPg0KICAgIE5ldyBkZXZlbG9wZXIgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0icmljYXJkb2xlY2hldGFAdXNlcnMuc291cmNlZm9yZ2UubmV0Ij5SaWNhcmRvIExlY2hldGE8L2E+IGpvaW5zIHRoZSBDbGljayBwcm9qZWN0Lg0KICAgIDwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgbmV3IG1ldGhvZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwjaXNBamF4UmVxdWVzdCgpIj5Db250ZXh0LmlzQWpheFJlcXVlc3QoKTwvYT4NCiAgICAgICAgd2hpY2ggZW5hYmxlcyBjb25kaXRpb25hbCBjaGVja2luZyBmb3IgQWpheCByZXF1ZXN0cy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCVVwZ3JhZGVkIHRvIFNjcmlwdGFjdWxvdXMgMS44LjEgdG8gZml4IGF1dG8gZm9ybSBzdWJtaXQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBbmR5IEtleS4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMzYiPjMzNjwvYT5dLg0KCSAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgZGVwbG95bWVudCBvZiByZXNvdXJjZXMgd2hlbiBzZXJ2bGV0IGNvbnRhaW5lciBkb2VzIG5vdCB1bnBhY2sgd2FyLg0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM0MCI+MzQwPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBzZW5kUmVkaXJlY3QgdG8gY29udmVydCA8ZW0+LmpzcDwvZW0+IGV4dGVuc2lvbiB0byA8ZW0+Lmh0bTwvZW0+IHdoZW4gcmVkaXJlY3RpbmcgdG8gYSBKU1AgcGFnZS4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMzgiPjMzODwvYT5dLg0KCSAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRm9ybSA8dHQ+Y2xlYXJWYWx1ZXMoKTwvdHQ+IHRvIGV4Y2x1ZGUgY2VydGFpbiBIaWRkZW5GaWVsZHMgZnJvbSBiZWluZyBjbGVhcmVkLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMzNyI+MzM3PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBGb3JtIGFjdGlvbiBpbmNvcnJlY3Qgd2hlbiB1c2luZyBKU1AuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBDaGFzIEVyaWNrc29uLg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMzNCI+MzM0PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNvblN1Ym1pdENoZWNrKG9yZy5hcGFjaGUuY2xpY2suUGFnZSwgamF2YS5sYW5nLlN0cmluZykiPkZvcm0ub25TdWJtaXRDaGVjaygpPC9hPg0KICAgICAgICB0byBpZ25vcmUgQWpheCBjYWxscy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEl2YW4gRnVyZGkuDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzMzIj4zMzM8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIEZvcm0gYW5kIEZpZWxkU2V0IGNvbHVtbiBsYXlvdXQgYnVnDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzMxIj4zMzE8L2E+XS4NCgkgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFRhYmxlIGNvbHVtbiBzb3J0aW5nIGlzc3VlIHdpdGggc3RyaW5nIHZhbHVlcy4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEJlbiBZb3VuZw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM0NCI+MzQ0PC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBUYWJsZSBzdHlsZSBpc3N1ZXMgd2l0aCBzb3J0ZWQgY29sdW1ucw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTM0NSI+MzQ1PC9hPl0uDQoJICA8L2xpPg0KICAJPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+PGEgbmFtZT0iMS40Ij48L2E+VmVyc2lvbiAxLjQgLSAyIE1hcmNoIDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlVcGRhdGVkIENheWVubmUgY29udHJvbHMgdG8gc3VwcG9ydCBDYXllbm5lIHZlcnNpb24gMy4wLg0KCSAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ2F5ZW5uZUZvcm0gPHR0PnNhdmUoKTwvdHQ+IG1ldGhvZCBpbnNlcnRpbmcgbXVsdGlwbGUgbmV3IGVudHJpZXMgYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIFRvcmUgSGFsc2V0DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzA3Ij4zMDc8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFRhYmxlIGludmFsaWQgaGFuZGxpbmcgcGFyYW1zIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBTYXRvc2hpIFRha2F0YQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMwOCI+MzA4PC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBEYXRlRmllbGQgcmVhZG9ubHkgSmF2YVNjcmlwdCBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBUb3JlIEhhbHNldA0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMwOSI+MzA5PC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBEYXRlRmllbGQgRHV0Y2ggQ2FsZW5kYXIgdHJhbnNsYXRpb24uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBIYXJyeSBXaXNzaWFrDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzEwIj4zMTA8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIERhdGVGaWVsZCA8dHQ+JGltcG9ydHM8L3R0PiB1c2FnZSBKYXZhU2NyaXB0IGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEl0b3UgQWtpaGlybw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxMSI+MzExPC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBidWcgd2hlcmUgY2hhcnNldCBlbmNvZGluZyBiZWluZyBzZXQgYWZ0ZXIgcmVxdWVzdCBwYXJhbWV0ZXJzIGFyZSByZWFkLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxMiI+MzEyPC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBUaHJlYWRMb2NhbCBDb250ZXh0IGZvcndhcmRpbmcgYnVnIG9uIEpldHR5IDUuMS4qLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgUmljYXJkbyBMZWNoZXRhDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzE0Ij4zMTQ8L2E+XS4NCgkgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkICdzY3JpcHQuYWN1bG8udXMnIEFqYXguQXV0b2NvbXBsZXRlciBidWcgd2l0aCBJRS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEl0b3UgQWtpaGlybw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyMiI+MzIyPC9hPl0uDQoJICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBDb21wcmVzc2lvblNlcnZsZXRSZXNwb25zZVdyYXBwZXIgTlBFIGJ1Z3Mgb24gV2ViU3BoZXJlIGFuZCBKZXR0eS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFJpY2FyZG8gTGVjaGV0YSBhbmQgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMyMyI+MzIzPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCgk8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDEuNCBSQzMgLSA2IEZlYnJ1YXJ5IDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2ZpbHRlci9QZXJmb3JtYW5jZUZpbHRlci5odG1sIj5QZXJmb3JtYW5jZUZpbHRlcjwvYT4NCgkJdG8gc2lnbmlmaWNhbnRseSBpbXByb3ZlIHRoZSBwZXJmb3JtYW5jZSBvZiBDbGljayBhcHBsaWNhdGlvbnMNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yODQiPjI4NDwvYT4sIDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yOTAiPjI5MDwvYT5dLg0KCQk8cC8+DQoJCUNsaWNrIEZyYW1ld29yayBub3cgc3VwcG9ydHMNCgkJPGEgaHJlZj0iaHR0cDovL2RldmVsb3Blci55YWhvby5jb20vcGVyZm9ybWFuY2UvcnVsZXMuaHRtbCI+RXhjZXB0aW9uYWwgUGVyZm9ybWFuY2U8L2E+DQogICAgICAgIGJlc3QgcHJhY3RpY2VzIGZvciBzcGVlZGluZyB1cCB5b3VyIHdlYiBzaXRlLg0KCQlUaGlzIGZpbHRlciBjb21iaW5lZCB3aXRoIGZyYW1ld29yayBjaGFuZ2VzIGVuYWJsZSBDbGljayBhcHBsaWNhdGlvbnMgdG8gZ2V0DQoJCWFuIEdyYWRlIEEgcmF0aW5nIHdpdGggWWFob28ncyBZU2xvdy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAyczA5Lmh0bWwiPlN0YXRlZnVsIFBhZ2VzPC9hPiB0b3BpYyBhbmQNCgkJY29tcGxldGVkIGZyYW1ld29yayBzdXBwb3J0IGZvciBzZXJpYWxpemluZyBzdGF0ZWZ1bCBQYWdlcyBhbmQgdGhlaXIgY29udHJvbHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBuZXcgQUpBWCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvQXV0b0NvbXBsZXRlVGV4dEZpZWxkLmh0bWwiPkF1dG9Db21wbGV0ZVRleHRGaWVsZDwvYT4gd2hpY2ggcHJvdmlkZXMgR29vZ2xlIHN1Z2dlc3Qgc3R5bGUgbG9va3Vwcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG5ldyBUYWJsZSBDU1MgY2xhc3Mgc3R5bGVzOiA8dHQ+Ymx1ZTEsIGJsdWUyLCBvcmFuZ2UxLCBvcmFuZ2UyPC90dD4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCVVwZGF0ZWQgPHR0PkZvcm0uY29weUZyb20oKTwvdHQ+IHRvIGFsaWduIHdpdGggc3BlY2lhbCBNYXAgaGFuZGxpbmcgb2YgPHR0PkZvcm0uY29weVRvKCk8L3R0Pi4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjc4Ij4yNzg8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJICAgIFVwZGF0ZWQgRm9ybSBzdWJtaXQgY2hlY2sgdG8gaGFuZGxlIG11bHRpcGxlIGZvcm1zIHBlciBwYWdlLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNzkiPjI3OTwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgVXBkYXRlZCBUYWJsZSB0byBudWxsaWZ5IHJvd0xpc3QgcHJvcGVydHkuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI4MyI+MjgzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIDx0dD5Db250cm9sczwvdHQ+IHRvIHVzZSB0aGUgbmV3IEFQSQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0Q29udHJvbC5odG1sI2FkZFN0eWxlQ2xhc3MoamF2YS5sYW5nLlN0cmluZykiPmFkZFN0eWxlQ2xhc3MoU3RyaW5nKTwvYT4gYW5kDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWJzdHJhY3RDb250cm9sLmh0bWwjc2V0U3R5bGUoamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLlN0cmluZykiPnNldFN0eWxlKFN0cmluZywgU3RyaW5nKTwvYT4NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yODYiPjI4NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgVXBkYXRlZCBKUyBhZGRMb2FkRXZlbnQoKSB0byB1c2UgUHJvdG90eXBlIEZpeGVkIGV4Y2VwdGlvbiB3aGVuIHVzaW5nIDx0dD5Gb3JtLm9uU2VjdXJ0eUNoZWNrPC90dD4gaW4gYSBzdGF0ZWZ1bCBmb3JtLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI0NSI+MjQ1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBUYWJsZSA8dHQ+aXNpPC90dD4gc3R5bGUgcmVuZGVyaW5nIHByb2JsZW1zLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSi5GLiBaYXJhbWENCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOTYiPjE5NjwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRGF0ZUZpZWxkIEphdmFTY3JpcHQgZm9ybWF0IHBhdHRlcm4gYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSXRvdSBBa2loaXJvIGFuZCBmaXhlZCBieSBJdG91IEFraWhpcm8gYW5kIE5hb2tpIFRha2V6b2UNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNTAiPjI1MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkgICAgRml4ZWQgZXhjZXB0aW9uIHdoZW4gdXNpbmcgPHR0PkZvcm0ub25TZWN1cml0eUNoZWNrPC90dD4gaW4gYSBzdGF0ZWZ1bCBmb3JtLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSm9lbCBTY2htaWR0DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjY3Ij4yNjc8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFBpY2tMaXN0IG11bHRpcGxlIHNlbGVjdGlvbiBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yODAiPjI4MDwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ29udGV4dCBsZWFrIHVuZGVyIGhlYXZ5IHVzYWdlLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yODIiPjI4MjwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgUGFnZSBhdXRvbWFwcGluZyBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBTZXAgYW5kIFJpY2FyZG8gTGVjaGV0YQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3NyI+Mjc3PC9hPiwNCgkJIDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yOTQiPjI5NDwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgTGludXggUmVzb3VyY2VCdW5kbGUgY2xhc3Nsb2FkaW5nIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFZpY3Rvcg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI5MyI+MjkzPC9hPl0uDQoJICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBUcmVlIGVuY29kZVVSTCBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgVGhvbWFzIEJlcm5oYXJkDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzAxIj4zMDE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIFRhYmxlIG1lbW9yeSBhbGxvY2F0aW9uIGJ1ZyBmb3IgbGFyZ2UgcGFnZWQgcm93TGlzdHMuDQoJCVRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgTmFva2kgVGFrZXpvZQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMwNSI+MzA1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDIuMC40LCB3aGljaCBmaXhlcyBhIG1lbW9yeSBsZWFrIGluDQogICAgICAgIHZlcnNpb24gMi4wMy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEJvYiBTY2hlbGxpbmsNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yODEiPjI4MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCB0aGUgSmF2YVNjcmlwdCBQcm90b3R5cGUgbGlicmFyeSB0byB2ZXJzaW9uIDEuNS4wIGFuZCAnc2NyaXB0LmFjdWxvLnVzJyB0byB2ZXJzaW9uIDEuNy4wLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjQgUkMyIC0gMiBKYW51YXJ5IDIwMDg8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBwcm9wZXJ0eSBmaWxlcyB3aXRoIHRyYW5zbGF0aW9uIGZvciB0aGUgQ3plY2ggbGFuZ3VhZ2UuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgRGF2aWQgTWFya28NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMzgiPjI0MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgZmFjaWxpdHkgdG8gbG9hZCA8dHQ+Y2xpY2sueG1sPC90dD4gZnJvbSBjbGFzcyBwYXRoIGlmIG5vdCBmb3VuZA0KCQl1c2VyIDx0dD5XRUItSU5GPC90dD4uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgQW5kcmUgQnJlbWVyDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjczIj4yNzM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIENhbGVuZGFyIHByb3BlcnR5IGFuZCBKUyBmaWxlcyB3aXRoIHRyYW5zbGF0aW9uIGZvciB0aGUgRHV0Y2ggbGFuZ3VhZ2UuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBhbmQgZml4ZWQgYnkgSGFycnkgV2lzc2lhaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3NSI+Mjc1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlBZGRlZCBUYWJsZSBwcm9wZXJ0eSA8dHQ+Y2xlYXJSb3dMaXN0T25EZXN0cm95PC90dD4uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBKb2VsIFNjaG1pZHQNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNjgiPjI2ODwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJVXBkYXRlZCBFeHRlcm5hbExpbmsgY29udHJvbCByZW5hbWluZyBtZXRob2QgPHR0PnNldFBhZ2VDbGFzczwvdHQ+IHRvIDx0dD5zZXRUYXJnZXRQYXRoPC90dD4uDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBJdG91IEFraWhpcm8NCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNDQiPjI0NDwvYT5dLg0KICAgICAgPC9saT4NCgkgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJVXBkYXRlZCBGaWVsZFNldCB0byBzdXBwb3J0IHJlbmRlcmluZyB3aXRob3V0IGEgTGVnZW5kLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSm9lbCBTY2htaWR0DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjU3Ij4yNTc8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCVVwZGF0ZWQgTWVzc2FnZU1hcCB0byBpbXByb3ZlIGNhY2hlIGtleS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjc0Ij4yNzQ8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIGJ1ZyB3aGVyZSBkb3VibGUgImNsYXNzIiBhdHRyaWJ1dGVzIGFyZSByZW5kZXJlZCBpbiBIVE1MIGZvciBGaWVsZA0KCQljb250cm9scyBpZiB2YWxpZGF0aW9uIGlzIGZhaWxlZC4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIFNodW8gR2VuZyBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIzMyI+MjMzPC9hPl0uDQogICAgICA8L2xpPg0KCSAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCB0cmFuc2xhdGlvbiBlcnJvcnMgZm9yIEZyZW5jaCBwcm9wZXJ0aWVzLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFBhdHJpY2sgVGFsYm90DQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjM4Ij4yMzg8L2E+XS4NCiAgICAgIDwvbGk+DQoJICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIENsaWNrVXRpbHMgPHR0PmNvcHlGb3JtVG9PYmplY3QoKTwvdHQ+IG1ldGhvZCA8dHQ+TWFwPC90dD4gc3VwcG9ydC4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEhhcnJ5IFdpc3NpYWsgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMzkiPjIzOTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgSlNQIHBhZ2UgcmVjdXJzaW9uIGJ1ZyB3aGVuIG5vdCBib3JkZXIgdGVtcGxhdGUgZGVmaW5lZC4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBSaWNhcmRvIExlY2hldGENCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMzciPjIzNzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgRGF0YUNvbnRleHRGaWx0ZXIgYWx3YXlzIGNyZWF0aW5nIEh0dHBTZXNzaW9uIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEZsb3JpbiBULlBBVFJBU0NVDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjQwIj4yNDA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIENsaWNrQXBwIE5QRSBidWcgb24gT0M0SiBhcHBsaWNhdGlvbiBzZXJ2ZXIuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBIYXJyeSBXaXNzaWFrDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjQ4Ij4yNDg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIENvbnRleHQgaGFuZGxpbmcgb2YgbXVsdGl2YWx1ZSBwYXJhbWV0ZXJzIG9uIG11bHRpcGFydCBmaWxlIHVwbG9hZCByZXF1ZXN0cy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEJvYiBTY2hlbGxpbmsNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNTIiPjI1MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgY2xhc3Nsb2FkZXIgaXNzdWUgd2hlbiBjbGljayBKQVJTIG5vdCBjb250YWluZWQgaW4gd2ViIGFwcGxpY2F0aW9uLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgSGFycnkgV2lzc2lhaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI1NiI+MjU2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBtaXNzaW5nIGxhbmd1YWdlIHByb3BlcnRpZXMuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjY5Ij4yNjk8L2E+LA0KCQkgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3MSI+MjcxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBGb3JtVGFibGUgbWlzc2luZyBmaWVsZCBpbXBvcnRzIGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEZyYW7nb2lzLVhhdmllciBHdWlsbGVtZXR0ZQ0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3MiI+Q0xLLTI3MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ2xpY2tVdGlscyA8dHQ+Z2V0TWltZVR5cGUoKTwvdHQ+IG5vdCBzdXBwb3J0aW5nIHVwcGVyIGNhc2UgZmlsZSBleHRlbnNpb25zLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQmVuIFdhcm5lcg0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3NiI+Q0xLLTI3NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjQgUkMxIC0gMTUgU2VwdGVtYmVyIDIwMDc8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXBvcnRhbnQgQ2hhbmdlDQoJCXRoZSBQYWdlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNzdGF0ZWZ1bCI+c3RhdGVmdWw8L2E+IHByb3BlcnR5DQoJCWFkZGVkIHRvIHN1cHBvcnQgcGVyc2lzdGVuY2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXBvcnRhbnQgQ2hhbmdlDQoJCXRoZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwiPkNvbnRleHQ8L2E+IG9iamVjdA0KCQlpcyBub3cgYXZhaWxhYmxlIGluIFBhZ2UgYW5kIENvbnRyb2wgY29uc3RydWN0b3JzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJSW1wb3J0YW50IENoYW5nZQ0KCQlhZGRlZCBDb250cm9sIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRyb2wuaHRtbCNvbkluaXQoKSI+b25Jbml0KCk8L2E+DQoJCWluaXRpYWxpemF0aW9uIGV2ZW50IGhhbmRsZXIuDQoJCUFzIHRoZSA8dHQ+c2V0Q29udGV4dCgpPC90dD4gbWV0aG9kIGhhcyBiZWVuDQoJCXJlbW92ZWQgYW55IGNvbnRyb2wgaW5pdGlhbGl6YXRpb24gY29kZSBjb250YWluZWQgaW4gdGhpcyBtZXRob2Qgc2hvdWxkIGJlDQoJCW1pZ3JhdGVkIHRvIHRoZSBuZXcgY29udHJvbCA8dHQ+b25Jbml0KCk8L3R0PiBtZXRob2QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXBvcnRhbnQgQ2hhbmdlDQoJCXRoZSBYTUwgY29uZmlndXJlZCByb290IE1lbnUgaXRlbSBpcyBvYnRhaW5lZCB2aWEgdGhlIHN0YXRpYyBtZXRob2QNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCNnZXRSb290TWVudSgpIj5nZXRSb290TWVudSgpPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcG9ydGFudCBDaGFuZ2UNCgkJbXVsdGlwYXJ0IGZpbGUgdXBsb2FkIHJlcXVlc3RzIGFyZSBub3cgcHJvY2Vzc2VkIHVzaW5nIGEgZ2xvYmFsbHkgY29uZmlndXJlZCBDb21tb25zIEZpbGVVcGxvYWQNCgkJY2xhc3MuIFBsZWFzZSBzZWUgdGhlDQoJCTxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3NlcnZpY2UvQ29tbW9uc0ZpbGVVcGxvYWRTZXJ2aWNlLmh0bWwiPkNvbW1vbnNGaWxlVXBsb2FkU2VydmljZTwvYT4NCgkJZm9yIG1vcmUgZGV0YWlscy4gVGhpcyBjaGFuZ2UgZW5hYmxlcyBmb3IgcmVxdWVzdCBwYXJhbWV0ZXIgYXV0byBiaW5kaW5nDQoJCW9uIG11bHRpcGFydCBmaWxlIHVwbG9hZCByZXF1ZXN0cy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcG9ydGFudCBDaGFuZ2UNCgkJQ2xpY2sgRXh0cmFzIG5vdyBzdXBwb3J0cyBBcGFjaGUgQ2F5ZW5uZSAyLnggcmF0aGVyIHRoYW4gT2JqZWN0c3R5bGUgQ2F5ZW5uZSAxLjIueA0KCQlieSBkZWZhdWx0LiBOb3RlIGJhY2t3YXJkIGNvbXBhdGliaWxpdHkgQ2F5ZW5uZSAxLjIueCBKQVJTIGFyZSBwcm92aWRlIGluIHRoZSBkaXN0IGRpcmVjdG9yeS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIENvbnRyb2wgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI29uUmVuZGVyKCkiPm9uUmVuZGVyKCk8L2E+DQoJCXJlbmRlciBldmVudCBoYW5kbGVyLiBUaGlzIG1ldGhvZCBpcyB1c2VmdWwgZm9yIFBhbmVsIGNvbnRyb2xzIHBvcHVsYXRpbmcgdGFibGVzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgQ29udHJvbCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwjb25EZXN0cm95KCkiPm9uRGVzdHJveSgpPC9hPg0KCQlkZXN0cm95IGV2ZW50IGhhbmRsZXIuIFRoaXMgbWV0aG9kIGlzIHVzZWZ1bCBmb3IgY29udHJvbHMgdG8gZnJlZSByZXNvdXJjZXMsIHdoZW4gdGhlIGNvbnRyb2xzDQoJCWFyZSBjb250YWluZWQgaW4gc3RhdGVmdWwgcGFnZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9FeHRlcm5hbExpbmsuaHRtbCI+RXh0ZXJuYWxMaW5rPC9hPiBjb250cm9sLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBBYnN0cmFjdENvbnRyb2wgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9BYnN0cmFjdENvbnRyb2wuaHRtbCNnZXRQYWdlKCkiPmdldFBhZ2UoKTwvYT4gbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBDb250ZXh0IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNnZXRSZXF1ZXN0UGFyYW1ldGVyVmFsdWVzKCkiPmdldFJlcXVlc3RQYXJhbWV0ZXJWYWx1ZXMoKTwvYT4gbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBDb250ZXh0IDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNpc0dldCgpIj5pc0dldCgpPC9hPiBtZXRob2QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIEZpZWxkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNoZWxwIj5oZWxwPC9hPiBwcm9wZXJ0eQ0KICAgICAgCXRvIHJlbmRlciBoZWxwIHRleHQgdG8gdGhlIHJpZ2h0IGhhbmQgc2lkZSBvZiBmaWVsZHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIE1lbnUgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCNpbWFnZVNyYyI+aW1hZ2VTcmM8L2E+IHByb3BlcnR5DQogICAgICAJdG8gc3VwcG9ydCBmb3IgcmVuZGVyaW5nIGltZyBpY29ucyBpbiBtZW51cy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlbmFtZWQgQ29udGV4dCBtZXRob2QgPHR0PmdldFJlcXVlc3RQYXJhbWV0ZXJzPC90dD4gdG8NCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI2dldFJlcXVlc3RQYXJhbWV0ZXJNYXAoKSI+Z2V0UmVxdWVzdFBhcmFtZXRlck1hcDwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCVVwZGF0ZSBsb2NhbGl6YXRpb24gY2xpY2stY29udHJvbF9wdF9CUi5wcm9wZXJ0aWVzIHByb3ZpZGVkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjIxIj4yMjE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgU2VsZWN0LCBDaGVja0xpc3QgYW5kIFBpY2tMaXN0IGNvbnRyb2xzIHRvIHVzZSBzdGFuZGFyZA0KICAgICAgICA8dHQ+Z2V0U2VsZWN0ZWRWYWx1ZXMoKTwvdHQ+IG1ldGhvZC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IENocmlzdG9waGUgRk9JUkVUDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMjEiPjIyNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlSZW1vdmVkIFBhZ2UgYW5kIENvbnRyb2wgPHR0PnNldENvbnRleHQoKTwvdHQ+IG1ldGhvZHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCVJlbW92ZWQgRmlsZUZpZWxkIDx0dD5maWxlVXBsb2FkPC90dD4gcHJvcGVydHkuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBQYWdlIGNvbnRyb2wgYXV0b2JpbmRpbmcgYnVnLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgQ2hyaXN0b3BoZSBGT0lSRVQNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOTUiPjE5NTwvYT4sIDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOTUiPjIxMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJRml4ZWQgQ2xpY2tBcHAgbm90IHBpY2tpbmcgdXAgbmV3IFBhZ2UgY2xhc3NlcyBkeW5hbWljYWxseS4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjIyIj4yMjI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgRm9ybSBpc0Zvcm1TdWJtaXNzaW9uKCkgbWV0aG9kIGZhaWxzIHdoZW4gY2FsbGVkIHR3aWNlIHdpdGggbXVsdGktcGFydCByZXF1ZXN0IGJ1Zw0KICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMjQiPjIyNDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBtYWNyby52bSBpcyBvbmx5IGF2YWlsYWJsZSBpZiB3YXIgaXMgdW5wYWNrZWQgYnVnLiBUaGlzIGlzc3VlIHdhcw0KICAgICAgCXJhaXNlZCBieSBBbmRydXMgQWRhbWNoaWsgYW5kIGZpeGVkIGJ5IEJvYiBTY2hlbGxpbmsNCiAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjMwIj4yMzA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIE9HTkwgRG91YmxlIHRvIEJpZ0RlY2ltYWwgdHlwZSBjb252ZXJzaW9uIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkDQoJCWJ5IEJlbiBXYXJuZXIgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vamlyYS5vcGVuc3ltcGhvbnkuY29tL2Jyb3dzZS9PR05MLTEyMiI+T0dOTC0xMjI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQ2F5ZW5uZSBsaWJyYXJ5IHRvIHZlcnNpb24gMi4wLjMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDEuMy4xIC0gMTEgSnVuZSAyMDA3PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvQ2F5ZW5uZUZvcm0uaHRtbCI+Q2F5ZW5uZUZvcm08L2E+DQogICAgICAgIHRvIGhhbmRsZSBub24gaW50ZWdlciBwcmltYXJ5IGtleSB2YWx1ZXMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBUb3JlIEhhbHNldA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIxMSI+MjExPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBSYWRpb0dyb3VwIGlzIHN0aWxsIGFjdGl2ZSB3aGVuIHNldCBpdCB0byBkaXNhYmxlZCBidWcuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBDaHJpc3RvcGhlIEZPSVJFVA0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjE4Ij4yMTg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEZvcm0gZmlsZSB1cGxvYWQgY2hhcmFjdGVyIGVuY29kaW5nIE5QRS4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIFJvc2Vuc3RhcmsNCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIyMCI+MjIwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENvbW1vbnMgRmlsZVVwbG9hZCBsaWJyYXJ5IHRvIHZlcnNpb24gMS4yLiBGaXhlcyBidWcgd2hlcmUgZmlsZQ0KICAgICAgICBuYW1lcyBhcmUgYmVpbmcgY29udmVydGVkIGludG8gbG93ZXJjYXNlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBDb21tb25zIElPIGxpYnJhcnkgdG8gdmVyc2lvbiAxLjMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDEuMi4zLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBTcHJpbmcgbGlicmFyeSB0byB2ZXJzaW9uIDEuMi45Lg0KICAgICAgPC9saT4NCiAgICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjMgLSA1IEp1bmUgMjAwNzwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcG9ydGFudCBDaGFuZ2UNCgkJdGhlIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDAyczAyLmh0bWwjYWN0aXZpdHktZGlhZ3JhbSI+UGFnZXM8L2E+IGV2ZW50IGV4ZWN1dGlvbiBvcmRlcg0KCQloYXMgY2hhbmdlZCB3aXRoIHRoZSA8dHQ+b25TZWN1cml0eUNoZWNrKCk8L3R0PiBtZXRob2Qgbm93IGludm9rZWQgYmVmb3JlDQoJCXRoZSA8dHQ+b25Jbml0KCk8L3R0PiBtZXRob2QuIFRoZSBiZW5lZml0IG9mIHRoaXMgaXMgdGhhdCB0aGUgPHR0Pm9uSW5pdCgpPC90dD4NCgkJaXMgb25seSBpbnZva2VkIGlmIHRoZSByZXF1ZXN0IGhhcyBwYXNzZWQgdGhlIDx0dD5vblNlY3VyaXR5Q2hlY2soKTwvdHQ+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZA0KICAgICAgCTxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9QaWNrTGlzdC5odG1sIj5QaWNrTGlzdDwvYT4gY29udHJvbC4NCiAgICAgIAlUaGlzIGNvbnRyb2wgd2FzIGNyZWF0ZWQgYnkgTmFva2kgVGFrZXpvZQ0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTk0Ij4xOTQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvdHJlZS9UcmVlLmh0bWwiPlRyZWU8L2E+IGNvbnRyb2wgY2xpZW50IHNpZGUgamF2YXNjcmlwdCBmdW5jdGlvbmFsaXR5Lg0KCQlUaGlzIHdhcyBwcm92aWRlZCBieSBCb2IgU2NoZWxsaW5rDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTg2Ij4xODY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDRzMDIuaHRtbCNhcHBsaWNhdGlvbi1hdXRvYmluZGluZyI+YXV0b2JpbmRpbmc8L2E+IGNvbmZpZ3VyYXRpb24gb3B0aW9uLg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBBaG1lZCBNb2hvbWJlDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xOTkiPjE5OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCgkJQWRkZWQgPHR0PnRhYmluZGV4PC90dD4gc3VwcG9ydCB0bw0KCQk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Fic3RyYWN0TGluay5odG1sIj5BYnN0cmFjdExpbms8L2E+IGFuZA0KCQk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwiPkZpZWxkPC9hPiBjb250cm9scy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUFkZGVkIEZvcm0NCgkJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjZGVmYXVsdEZpZWxkU2l6ZSI+ZGVmYXVsdEZpZWxkU2l6ZTwvYT4gcHJvcGVydHkuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlJbXByb3ZlZCA8dHQ+dHJhY2U8L3R0PiBsZXZlbCBsb2dnaW5nIHRvIGRldGFpbCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwiPlBhZ2U8L2E+IGV2ZW50IGV4ZWN1dGlvbiBvcmRlci4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUltcHJvdmVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9FbWFpbEZpZWxkLmh0bWwiPkVtYWlsRmllbGQ8L2E+IHZhbGlkYXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlDaGFuZ2VkIGRlZmF1bHQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwiPkZvcm08L2E+IGVycm9yUG9zaXRpb24gZnJvbSA8dHQ+Im1pZGRsZSI8L3R0PiB0byA8dHQ+InRvcCI8L3R0Pi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9DYXllbm5lRm9ybS5odG1sIj5DYXllbm5lRm9ybTwvYT4NCgkJaGFuZGxpbmcgb2YgbmV3IG9iamVjdHMgYnVnLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQW5kcnVzIEFkYW1jaGlrDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzMiPjczPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpbGVGaWVsZC5odG1sIj5GaWxlRmllbGQ8L2E+DQoJCWNvbmZpZ3VyYXRpb25zIG5vdCBiZSBhcHBsaWVkIGluIGNlcnRhaW4gc2NlbmFyaW9zLg0KCQlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYW5kIGZpeGVkIGJ5IFNhZGFub3JpIEl0bw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE3OSI+MTc5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCBQYWdlIHdpdGggdHdvIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCI+VGFibGU8L2E+DQoJICAgIGNvbnRyb2xzIHByb2R1Y2VzIHVubmVlZGVkIGNzcyBzdHlsZSB0ZXh0IGJ1Zy4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEouRi4gWmFyYW1hDQoJCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTk3Ij4xOTc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQoJCUZpeGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9MaW5rRGVjb3JhdG9yLmh0bWwiPkxpbmtEZWNvcmF0b3I8L2E+IHRhYmxlIHNvcnRpbmcgc3VwcG9ydC4NCgkJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IExvdWlzIE1hcnRpbiBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluaw0KCQlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTIwNyI+MjA3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KCQlGaXhlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1RhYmxlLmh0bWwiPlRhYmxlPC9hPiBjb2x1bW4gc29ydGluZyBidWcuDQoJCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBMb3VpcyBNYXJ0aW4gYW5kIGZpeGVkIGJ5IE5hb2tpIFRha2V6b2UNCgkJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMDgiPjIwODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAxLjIgLSAyMm5kIE1hcmNoIDIwMDc8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjAuNWVtOyI+IE5ldyBkZXZlbG9wZXINCiAgICA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL3NhYm9iLyI+Qm9iIFNjaGVsbGluazwvYT4NCiAgICBqb2lucyB0aGUgQ2xpY2sgcHJvamVjdC48L2Rpdj4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgY29udHJvbHMNCiAgICAgIAk8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvVHJlZS5odG1sIj5UcmVlPC9hPiBhbmQNCiAgICAgIAk8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3RyZWUvQ2hlY2tib3hUcmVlLmh0bWwiPkNoZWNrYm94VHJlZTwvYT4uDQogICAgICAJVGhlc2UgY29udHJvbHMgd2VyZSBjcmVhdGVkIGJ5IEJvYiBTY2hlbGxpbmsNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNjAiPjE2MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBjb250cm9scyBKU0JhckNoYXJ0LCBKU0xpbmVDaGFydCBhbmQgSlNQaWVDaGFydC4NCiAgICAgIAlUaGVzZSBjb250cm9scyB3ZXJlIGNyZWF0ZWQgYnkgQWhtZWQgTW9ob21iZS4NCiAgICAgICAgPHNwYW4gY2xhc3M9InJlZCI+VXBkYXRlOjwvc3Bhbj4gdGhlc2UgY29udHJvbHMgd2VyZSBtb3ZlZCB0byB0aGUNCiAgICAgICAgPGEgY2xhc3M9ImV4dGVybmFsIiB0YXJnZXQ9Il9ibGFuayIgaHJlZj0iaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9wL2NsaWNrLWNoYXJ0cy8iPkNsaWNrIENoYXJ0czwvYT4NCiAgICAgICAgcHJvamVjdC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgRmllbGQgY29udmVuaWVuY2UgbWV0aG9kcyBmb3Igc2V0dGluZyBzdHlsZSwgdGV4dC1hbGlnbiBhbmQgd2lkdGggSFRNTCBhdHRyaWJ1dGVzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgbXVsdGlwbGUgQWN0aW9uQnV0dG9uIHBhcmFtZXRlcnMsIHNlZQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0FjdGlvbkJ1dHRvbi5odG1sI3NldFBhcmFtZXRlcihqYXZhLmxhbmcuU3RyaW5nLCBqYXZhLmxhbmcuU3RyaW5nKSI+c2V0UGFyYW1ldGVyKCk8L2E+DQogICAgICAgIGZvciBkZXRhaWxzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgQWJzdHJhY3RMaW5rDQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWJzdHJhY3RMaW5rLmh0bWwjaW1hZ2VTcmMiPmltYWdlU3JjPC9hPg0KICAgICAgICBwcm9wZXJ0eSBmb3IgcmVuZGVyaW5nIGltZyBpY29ucyBpbnNpZGUgbGlua3MuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIGNsYXNzIGhpZXJhcmNoeSBtZXNzYWdlcyBpbmhlcml0YW5jZSB0byA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL01lc3NhZ2VzTWFwLmh0bWwiPk1lc3NhZ2VzTWFwPC9hPi4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQW5kcnVzIEFkYW1jaGlrDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzQiPjc0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBBY3Rpb25CdXR0b24gc3VwcG9ydCB0byA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTGlua0RlY29yYXRvci5odG1sIj5MaW5rRGVjb3JhdG9yPC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEzNSI+MTM1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBvcmRlcmluZyBzdXBwb3J0IHRvIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9Qcm9wZXJ0eVNlbGVjdC5odG1sIj5Qcm9wZXJ0eVNlbGVjdDwvYT4uDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEYXZpZCBGcml6ZWxsZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE1NCI+MTU0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBGaWVsZFNldCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkU2V0Lmh0bWwjY29sdW1ucyI+Y29sdW1uczwvYT4gcHJvcGVydHkuDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IExvcmVuem8gT3JzZWxsaQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE1OCI+MTU4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBvcHRpb25hbCBwcm9wZXJ0eSB0byA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvUXVlcnlTZWxlY3QuaHRtbCNvcHRpb25hbCI+UXVlcnlTZWxlY3Q8L2E+IGFuZA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvUHJvcGVydHlTZWxlY3QuaHRtbCNvcHRpb25hbCI+UHJvcGVydHlTZWxlY3Q8L2E+IGNvbnRyb2xzLg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBMb3JlbnpvIE9yc2VsbGkNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNTYiPjE1NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBzdXBwb3J0IGZvciBOYW1lZFF1ZXJ5IG9iamVjdHMgaW4NCiAgICAgIAk8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvUHJvcGVydHlTZWxlY3QuaHRtbCNuYW1lZFF1ZXJ5Ij5Qcm9wZXJ0eVNlbGVjdDwvYT4uDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEYXZpZCBGcml6ZWxsZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE2NiI+MTY2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIEl0YWxpYW4gYW5kIEZyZW5jaCBDb2xvclBpY2tlciBhbmQgVGVsZXBob25lRmllbGQgcHJvcGVydGllcyBwcm92aWRlZCBieSBMb3JlbnpvIE9yc2VsbGkNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNzEiPjE3MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBDaGluZXNlIGxvY2FsaXphdGlvbiBwcm9wZXJ0aWVzIHByb3ZpZGVkIGJ5IExhcnJ5IExpDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTc3Ij4xNzc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvQ2xpY2tVdGlscy5odG1sIj5DbGlja1V0aWxzPC9hPg0KICAgICAgICBjb29raWUgaGFuZGxpbmcgbWV0aG9kcywgYW5kIGNvbnZlbmllbmNlIG1ldGhvZHMgaW4gdGhlIENvbnRleHQgY2xhc3MuDQogICAgICAJVGhlc2UgbWV0aG9kcyB3ZXJlIGRlcml2ZWQgZnJvbSB0aGUgQXRsYXNzaWFuDQogICAgICAJPGEgdGFyZ2V0PSJibGFuayIgY2xhc3M9ImV4dGVybmFsIiBocmVmPSJodHRwOi8vb3BlbnNvdXJjZS5hdGxhc3NpYW4uY29tL3NlcmFwaC9hcGlkb2NzL2NvbS9hdGxhc3NpYW4vc2VyYXBoL3V0aWwvQ29va2llVXRpbHMuaHRtbCI+Q29va2llVXRpbHM8L2E+DQogICAgICAJY2xhc3MuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTWVudS5odG1sIj5NZW51PC9hPiBwcm9wZXJ0aWVzDQogICAgICAgIGV4dGVybmFsIGFuZCB0YXJnZXQsIGFuZCBjaGFuZ2VkIDx0dD50b1N0cmluZygpPC90dD4gbWV0aG9kIHRvIHJlbmRlciBhbiBIVE1MIGFuY2hvciB0YWcuDQogICAgICAgIFRoZXNlIGNoYW5nZXMgc2ltcGxpZnkgbWVudSBWZWxvY2l0eSBtYWNyb3MuDQogICAgICAgIFBsZWFzZSBub3RlIHRoZSA8dHQ+aXNVc2VySW5Sb2xlcygpPC90dD4gbWV0aG9kIG5vdyByZXR1cm5zIGZhbHNlIGlmIHRoZXJlIGFyZSBubyByb2xlcw0KICAgICAgICBkZWZpbmVkIGZvciB0aGUgbWVudSBpdGVtLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvRGF0YUNvbnRleHRGaWx0ZXIuaHRtbCI+RGF0YUNvbnRleHRGaWx0ZXI8L2E+IHN1cHBvcnQgZm9yDQogICAgICAJc2Vzc2lvbiBvciByZXF1ZXN0IHNjb3BlIERhdGFDb250ZXh0IG9iamVjdHMsIGFuZCBjb250cm9sbGluZyB0aGUgdXNlIG9mIHRoZSBDYXllbm5lIHNoYXJlZCBjYWNoZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgQ2F5ZW5uZSBEQU8vU2VydmljZSBiYXNlIGNsYXNzIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9DYXllbm5lVGVtcGxhdGUuaHRtbCI+Q2F5ZW5uZVRlbXBsYXRlPC9hPg0KICAgICAgCXRvIENsaWNrIEV4dHJhcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgYXV0b21hcHBpbmcgc3VwcG9ydCBmb3IgL2NsaWNrL2Vycm9yLmh0bSBwYWdlcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIENsaWNrU2VydmxldCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNjcmVhdGVDbGlja0xvZ2dlcigpIj5jcmVhdGVDbGlja0xvZ2dlcigpPC9hPg0KICAgICAgICBtZXRob2QgdG8gc3VwcG9ydCBjdXN0b21pemluZyBDbGljayBydW50aW1lIGVuZ2luZSBsb2dnaW5nLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQm9iIFNjaGVsbGluay4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIENvbHVtbiA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NvbHVtbi5odG1sI3RpdGxlUHJvcGVydHkiPnRpdGxlUHJvcGVydHk8L2E+DQogICAgICAgIGF0dHJpYnV0ZSB0byBzdXBwb3J0IHJlbmRlcmluZyAmbHQ7dGQmZ3Q7IHRpdGxlIGF0dHJpYnV0ZXMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEYXZpZCBGcml6ZWxsZS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIDxhIGhyZWY9ImNsaWNrLWlkZS5odG1sIj5DbGlja0lERTwvYT4gZG9jdW1lbnRhdGlvbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIFBhZ2UgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDJzMDMuaHRtbCNyZXF1ZXN0LXBhcmFtLWF1dG8tYmluZGluZyI+UmVxdWVzdCBQYXJhbSBBdXRvIEJpbmRpbmc8L2E+IGRvY3VtZW50YXRpb24gdG9waWMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBCZXN0IFByYWN0aWNlcyA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNXMwMi5odG1sI3BhY2thZ2VzLWNsYXNzZXMiPlBhY2thZ2VzIGFuZCBDbGFzc2VzPC9hPiBkb2N1bWVudGF0aW9uIHRvcGljLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgdXNhYmlsaXR5IG9mIEZpZWxkIGxhYmVscywgcHJvdmlkaW5nIGZpZWxkIGxhYmVsIGZvY3VzIHN1cHBvcnQuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlIGFuZCBmaXhlZCBieSBTYWRhbm9yaSBJdG8NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNTkiPjE1OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ltYWdlU3VibWl0Lmh0bWwjc3JjIj5JbWFnZVN1Ym1pdDwvYT4NCiAgICAgIAlzcmMgcmVuZGVyaW5nIGJ5IHByZWZpeGluZyBjb250ZXh0IHBhdGgNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNjUiPjE2NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NvbHVtbi5odG1sI2dldEhlYWRlclRpdGxlKCkiPkNvbHVtbjwvYT4NCiAgICAgIAlpMThuIHN1cHBvcnQgZm9yIGhlYWRlciB0aXRsZXMuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNzYiPjE3NjwvYT5dLg0KDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUltcHJvdmVkIEZvcm0NCiAgICAgIAk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNlbmRUYWcoKSI+ZW5kVGFnKCk8L2E+DQogICAgICAJcmVuZGVyaW5nIHRvIGluY2x1ZGUgSmF2YVNjcmlwdCBmb2N1cyBhbmQgdmFsaWRhdGlvbiBjb2RlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCBUYWJsZSBjb2x1bW4gc29ydGluZy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJSW1wcm92ZWQgZXJyb3IgcmVwb3J0aW5nIGZvciBJbGxlZ2FsQXJndW1lbnRFeGNlcHRpb25zLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCBBYnN0cmFjdExpbmsgcmVuZGVyaW5nIG9mIGRpc2FibGVkIGxpbmtzLCBub3cgcmVuZGVyIGFzIGEgc3BhbiBlbGVtZW50Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlSZWZhY3RvcmVkIERvdWJsZUZpZWxkLCBJbnRlZ2VyRmllbGQgYW5kIExvbmdGaWVsZCB0byBzdWJjbGFzcw0KICAgICAgCTxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9OdW1iZXJGaWVsZC5odG1sIj5OdW1iZXJGaWVsZDwvYT4uDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEFobWVkIE1vaG9tYmUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMjAiPjEyMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlSZW1vdmVkIHN1cHBvcnQgZm9yIGxvZ2dpbmcgdG8gU2VydmxldCBsb2cuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIEFjdGlvbkxpbmsgc2V0VmFsdWVPYmplY3QoKSBub3Qgc2V0dGluZyBudWxsIHZhbHVlcy4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNTAiPjE1MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBtdWx0aXBsZSBGb3JtIHN1cHBvcnQgaW4gcGFnZXMgd2l0aCBhbiBmaWxlIHVwbG9hZCBmb3JtDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTUyIj4xNTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgcmVhZG9ubHkgc3VwcG9ydCBpbiA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NoZWNrYm94Lmh0bWwiPkNoZWNrYm94PC9hPiwNCiAgICAgIAk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1JhZGlvLmh0bWwiPlJhZGlvPC9hPiBhbmQNCiAgICAgIAk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1NlbGVjdC5odG1sIj5TZWxlY3Q8L2E+IGNvbnRyb2xzLg0KICAgICAgCVRoZXNlIGlzc3VlcyB3ZXJlIHJhaXNlZCBieSBMb3JlbnpvIE9yc2VsbGkgYW5kIERhdmlkIEZyaXplbGxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTU1Ij4xNTU8L2E+LA0KICAgICAgICAgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE2NCI+MTY0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIGVycm9yIHBvc2l0aW9uIHN1cHBvcnQgaW4gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL1RhYmJlZEZvcm0uaHRtbCI+VGFiYmVkRm9ybTwvYT4gY29udHJvbC4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgTG9yZW56byBPcnNlbGxpDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTU3Ij4xNTc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgZGlmZmVyZW5jZXMgb2YgSmF2YS9KYXZhU2NyaXB0IGVycm9yIG1lc3NhZ2UuDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBTYWRhbm9yaSBJdG8NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNjEiPjE2MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBmaXJzdCBkYXkgb2Ygd2VlayBidWcgaW4gPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0RhdGVGaWVsZC5odG1sIj5EYXRlRmllbGQ8L2E+IGNvbnRyb2wuDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZCBieSBTYWRhbm9yaSBJdG8NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNzAiPjE3MDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBGb3JtDQogICAgICAJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjY29weVRvKGphdmEubGFuZy5PYmplY3QpIj5jb3B5VG88L2E+DQogICAgICAJTWFwIHN1cHBvcnQuIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBMb3VpcyBNYXJ0aW4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNzIiPjE3MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBGaWxlRmllbGQgSmF2YVNjcmlwdCB2YWxpZGF0aW9uIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGFuZCBmaXhlZA0KICAgICAgCWJ5IFNhZGFub3JpIEl0bw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE3OCI+MTc4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIFByb3BlcnR5U2VsZWN0IGFwcGxpZXMgb3JkZXJpbmcgdHdpY2UgYnVnLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgTGFycnkgQnVudG9uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTgzIj4xODM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgd3JvbmcgZm9ybSBIVE1MIGdlbmVyYXRpb24uIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGENCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xODkiPjE4OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlIFZlbG9jaXR5IGxpYnJhcnkgdG8gdmVyc2lvbiAxLjUtYmV0YTIuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDEuMi4yLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KDQogIDxkdD5WZXJzaW9uIDEuMSAtIDIyIE5vdmVtYmVyIDIwMDY8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjAuNWVtOyI+IE5ldyBkZXZlbG9wZXINCiAgICA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL3NoYWJlcm1hbi8iPlN0ZXBoZW4gSGFiZXJtYW48L2E+DQogICAgam9pbnMgdGhlIENsaWNrIHByb2plY3QuPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIEZvcm0gZmllbGQgd2lkdGggZ3JpZCBsYXlvdXQgcmVuZGVyaW5nIG9wdGlvbi4gU2VlIHRoZSBGb3JtDQogICAgICAJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjYWRkKG9yZy5hcGFjaGUuY2xpY2suY29udHJvbC5GaWVsZCwgaW50KSI+YWRkKGZpZWxkLCB3aWR0aCk8L2E+IG1ldGhvZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgVGFibGUgQ29sdW1uIHNvcnRpbmcgc3VwcG9ydC4gU2VlIHRoZSBDb2x1bW4NCiAgICAgIAk8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NvbHVtbi5odG1sI3NvcnRhYmxlIj5zb3J0YWJsZTwvYT4gcHJvcGVydHkuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIENvbHVtbiBjb252ZW5pZW5jZSBtZXRob2RzIGZvciBzZXR0aW5nIHdpZHRoLCB0ZXh0LWFsaWduLA0KICAgICAgCXZlcnRpY2FsLWFsaWduIGF0dHJpYnV0ZXMsIGFuZCBzZXR0aW5nIGRhdGEgYW5kIGhlYWRlciBzdHlsZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIGF1dG8gYmluZGluZyBvZiByZXF1ZXN0IHZhbHVlcyB0byBwdWJsaWMgUGFnZSBmaWVsZHMuIFNlZSB0aGUgQ2xpY2tTZXJ2bGV0IG1ldGhvZA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNwcm9jZXNzUGFnZVJlcXVlc3RQYXJhbXMob3JnLmFwYWNoZS5jbGljay5QYWdlLCBqYXZheC5zZXJ2bGV0Lmh0dHAuSHR0cFNlcnZsZXRSZXF1ZXN0KSI+cHJvY2Vzc1BhZ2VSZXF1ZXN0UGFyYW1zKCk8L2E+DQogICAgICAgIGZvciBkZXRhaWxzLiBUaGlzIGFkZGl0aW9uIHdhcyByYWlzZWQgYnkgU3RlcGhlbiBIYWJlcm1hbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEZvcm0NCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjY2xlYXJWYWx1ZXMoKSI+Y2xlYXJWYWx1ZXMoKTwvYT4NCiAgICAgICAgbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgQ2xpY2tVdGlscw0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0NsaWNrVXRpbHMuaHRtbCNnZXRNaW1lVHlwZShqYXZhLmxhbmcuU3RyaW5nKSI+Z2V0TWltZVR5cGUoKTwvYT4NCiAgICAgICAgbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3Igb3ZlcnJpZGluZyBDbGljayBBcHBsaWNhdGlvbiBtb2RlIGJ5IGRlZmluaW5nIGEgU3lzdGVtIHByb3BlcnR5IDx0dD5jbGljay5tb2RlPC90dD4uDQogICAgICAgIEZvciBleGFtcGxlOiA8dHQ+LURjbGljay5tb2RlPXRyYWNlPC90dD4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJSW1wcm92ZWQgVGFibGUgcGFnaW5nIGFjcm9zcyB2ZXJ5IGxhcmdlIGxpc3RzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlJbXByb3ZlZCBUYWJsZSByZW5kZXJpbmcgcGVyZm9ybWFuY2UuDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTM2Ij4xMzY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJSW1wcm92ZWQgT0dOTCBmb3JtIGJpbmRpbmcgcGVyZm9ybWFuY2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBDbGljayBjb25maWd1cmF0aW9uIGRlZmF1bHRzOg0KICAgICAgICA8dWwgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+cGFnZSBhdXRvbWFwcGluZyBpcyBlbmFibGVkIGJ5IGRlZmF1bHQ8L2xpPg0KICAgICAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5nbG9iYWwgbm8gY2FjaGUgaGVhZGVycyBhcmUgdXNlZCBpZiBubyBoZWFkZXJzIGRlZmluZWQ8L2xpPg0KICAgICAgICA8L3VsPg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlVcGRhdGVkIENsaWNrU2VydmxldCB0byB1c2UgcmVzcG9uc2UgV3JpdGVyIHRvIHN1cHBvcnQgdGhlDQogICAgICAJPGEgaHJlZj0iaHR0cDovL21lc3NhZG1pbi5zb3VyY2Vmb3JnZS5uZXQvIj5NZXNzQWRtaW48L2E+IHNlc3Npb24gbW9uaXRvcmluZyB0b29sLg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgU3ZlbiBIZXJzY2hlbCBhbmQgYSBwYXRjaCB3YXMgcHJvdmlkZWQgYnkNCiAgICAgIAlCb2IgU2NoZWxsaW5rDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTQ2Ij4xNDY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgTlBFIGluIFByb3BlcnR5U2VsZWN0IHdoZW4gbGFiZWwgaXMgbnVsbC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTMyIj4xMzI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgT2dubEV4Y2VwdGlvbiBpbiBDb2x1bW4gd2hlbiBldmFsdWF0aW5nIG51bGwgcHJvcGVydHkgcGF0aHMuDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTMzIj4xMzM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgT2dubCBOdWxsIHByb3BlcnR5IGV2YWx1YXRpb24gYnVnIHdoZW4gaGFuZGxpbmcgRGF0ZSBwcm9wZXJ0aWVzLg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEYXZpZCBGcml6ZWxsZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEzNyI+MTM3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIEpTUCBwYWdlIGF1dG9tYXBwaW5nIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBhbmQgZml4ZWQgYnkgQm9iIFNjaGVsbGluaw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTE0MiI+MTQyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIEhpYmVybmF0ZUZvcm0gbm90IHdvcmtpbmcgZm9yIENHTGliIHByb3hpZXMuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQNCiAgICAgIAlhbmQgZml4ZWQgYnkgQ2Fyb2xpbmUgQnJpZmZhDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTQ0Ij4xNDQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgQ2F5ZW5uZUZvcm0gYnVnIHdoZXJlIEZPSUQgd2FzIG5vdCBiZWluZyB1cGRhdGVkIGZvciByZWNlbnRseSBjb21taXR0ZWQgRGF0YU9iamVjdC4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNDUiPjE0NTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgZGVwZW5kZW5jeSBvbiBEb3VnaCBMZWEncyBDb25jdXJyZW50IFV0aWxpdGllcyBsaWJyYXJ5IHZlcnNpb24gMS4zLjQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGUgVmVsb2NpdHkgMS41LWRldiBsaWJyYXJ5IHRvIFNWTiByZXZpc2lvbiA0NjcxNzkuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIE9HTkwgbGlicmFyeSB0byB2ZXJzaW9uIDIuNi45Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy4gQ2xpY2sgUXVpY2tzdGFydCBoYXMgYWxzbyBiZWVuIGFkZGVkDQogICAgICAgIGFzIGFuIGV4YW1wbGUgYXBwbGljYXRpb24uDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMS4wIC0gM3JkIE9jdG9iZXIgMjAwNjwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9ImNsaWNrLWNoZWF0LXNoZWV0LnBkZiI+Q2hlYXQgU2hlZXQ8L2E+IGd1aWRlLg0KICAgICAgCVRoaXMgZmVhdHVyZSB3YXMgcmFpc2VkIGJ5IEFobWVkIE1vaG9tYmUgYW5kIFJpY2FyZG8gTGVjaGV0YS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgQ29sdW1uIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQ29sdW1uLmh0bWwjbWF4TGVuZ3RoIj5tYXhMZW5ndGg8L2E+IHByb3BlcnR5DQogICAgICAJdG8gbGltaXQgdGhlIG51bWJlciBjaGFyYWN0ZXJzIGRpc3BsYXllZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgTlBFIGluIFRhYmxlIEFjdGlvbkxpbmsgcGFnaW5hdGlvbi4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IFJpY2FyZG8gTGVjaGV0YQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEyNCI+MTI0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIGN1c3RvbSBFcnJvclBhZ2Ugbm90IHJlc29sdmluZy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5IEdsZW4gU3RhbXBvdWx0emlzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTI2Ij4xMjY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgTnVtYmVyRm9ybWF0RXhjZXB0aW9uIGluIExpbmtEZWNvcmF0b3INCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEyNyI+MTI3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIE51bWJlckZvcm1hdEV4Y2VwdGlvbiB3aGVuIHVzaW5nIEZvcm0ub25TdWJtaXRDaGVjaygpIHdpdGggYSBGaWxlRmllbGQuDQogICAgICAJVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBTYXRvc2hpIFRha2F0YQ0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTI3Ij4xMjg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgQ2F5ZW5uZUZvcm0gYnVnIHdpdGggcmVxdWlyZWQgcHJvcGVydHkgc2V0IG9uIENoZWNrYm94Lg0KICAgICAgCVRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgIAlbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEyOSI+MTI5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUZpeGVkIFByb3BlcnR5U2VsZWN0IGJ1ZyB3aGVyZSBmaXJzdCBpdGVtIGRpc3BsYXlzIHR3aWNlIHVuZGVyIGNlcnRhaW4gY29uZGl0aW9ucy4NCiAgICAgIAlUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMzAiPjEzMDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlVcGRhdGVkIGFuZCB2ZXJpZmllZCBDbGljayBGcmFtZXdvcmsgYW5kIEV4dHJhcyBjb2RlYmFzZSBhZ2FpbnN0IDxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vZmluZGJ1Z3Muc291cmNlZm9yZ2UubmV0L2luZGV4Lmh0bWwiPkZpbmRCdWdzPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQ2F5ZW5uZSBsaWJyYXJ5IHRvIHZlcnNpb24gMS4yLjEuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDEuMCBSQzIgLSA2dGggU2VwdGVtYmVyIDIwMDY8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0ZsYXNoQXR0cmlidXRlLmh0bWwiPkZsYXNoQXR0cmlidXRlPC9hPg0KICAgICAgICBjbGFzcyBwcm92aWRpbmcgZmxhc2ggc2NvcGUgc2Vzc2lvbiBhdHRyaWJ1dGVzLiBPbmNlIGEgZmxhc2ggYXR0cmlidXRlDQogICAgICAgIGhhcyBiZWVuIGFjY2Vzc2VkIGZyb20gdGhlIHNlc3Npb24gaXQgaXMgcmVtb3ZlZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9MaW5rRGVjb3JhdG9yLmh0bWwiPkxpbmtEZWNvcmF0b3I8L2E+DQogICAgICAgIGNsYXNzIGZvciByZW5kZXJpbmcgYWN0aW9uIGxpbmtzIGluIGNvbHVtbiB0YWJsZXMuIFRoaXMgY2xhc3Mgd2FzIGluc3BpcmVkDQogICAgICAgIGJ5IFJpY2hhcmRvIExlY2hldGEncyA8dHQ+Vmlld0RlY29yYXRvcjwvdHQ+IHBhdHRlcm4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBwYWdpbmcgc3VwcG9ydCB0bw0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvRm9ybVRhYmxlLmh0bWwiPkZvcm1UYWJsZTwvYT4NCiAgICAgICAgY29udHJvbC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sIj5Gb3JtPC9hPg0KICAgICAgICBzdGFydFRhZygpIGFuZCBlbmRUYWcoKSBtZXRob2RzIHRvIHN1cHBvcnQgbGF5aW5nIG91dCBmb3JtcyBtYW51YWxseS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEZvcm0NCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjY2xlYXJFcnJvcnMoKSI+Y2xlYXJFcnJvcnMoKTwvYT4NCiAgICAgICAgbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgUGFnZSB0ZW1wbGF0aW5nIHN1cHBvcnQgZm9yIEpTUCBwYWdlcy4gVGhpcyBpc3N1ZSB3YXMgcmFpc2UgYnkgSHV5IERvLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgVGFpd2FuIHByb3BlcnRpZXMgZmlsZSBwcm92aWRlZCBieSBIdWFuZy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIG5ldyBDbGljayBMb2dvIHByb3ZpZGVkIGJ5IEFobWVkIE1vaG9tYmUuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBGb3JtIGNsaWVudCBzaWRlIEphdmFTY3JpcHQgdmFsaWRhdGlvbiBwcm92aWRlZCBieSBOYW9raSBUYWtlem9lDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTE1Ij4xMTU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJVXBkYXRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NvbHVtbi5odG1sIj5Db2x1bW48L2E+DQogICAgICAgIGNsYXNzIHRvIGVzY2FwZSBIVE1MIGNoYXJhY3RlcnMgYnkgZGVmYXVsdC4gVGhpcyBpc3N1ZSB3YXMgcmFpc2VkIGJ5DQogICAgICAgIEdsZW4gU3RhbXBvdWx0emlzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTE4Ij4xMTg8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9IdG1sU3RyaW5nQnVmZmVyLmh0bWwiPkh0bWxTdHJpbmdCdWZmZXI8L2E+DQogICAgICAgIHRvIGltcHJvdmUgSFRNTCBjaGFyYWN0ZXIgZXNjYXBpbmcgcGVyZm9ybWFuY2UsIHJlbW92aW5nIEFwYWNoZSBDb21tb25zIExhbmcncyB1c2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9maXNoZXllMy5jZW5xdWEuY29tL2Jyb3dzZS9jbGljay8iPkZpc2hFeWU8L2E+IHByb2plY3Qgdmlldw0KICAgICAgICBwcm92aWRlZCBieSA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vd3d3LmNlbnF1YS5jb20iPkNlbnF1YTwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIENheWVubmUgbGlicmFyeSB0byB2ZXJzaW9uIDEuMi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgSGliZXJuYXRlIGxpYnJhcnkgdG8gdmVyc2lvbiAzLjEuMy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJRml4ZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9maWx0ZXIvQ29tcHJlc3Npb25GaWx0ZXIuaHRtbCI+Q29tcHJlc3Npb25GaWx0ZXI8L2E+DQogICAgICAgIHRvIGNvbXByZXNzIHJlc3BvbnNlIGJ5IGRlZmF1bHQgYW5kIHRvIGF1dG9tYXRpY2FsbHkgc2V0IGFueSBjb25maWd1cmVkIENsaWNrIGNoYXJzZXQuDQogICAgICAgIFRoZXNlIGlzc3VlcyB3ZXJlIHJhaXNlZCBieSBSaWNhcmRvIExlY2hldGEgYW5kIE5hb2tpIFRha2V6b2UNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMTkiPjExOTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlGaXhlZCBOUEUgaW4gRGF0ZUZpZWxkIHdoZW4gc2V0dGluZyB2YWx1ZSB0byBudWxsLiBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgR2VvZmYgSG9wc29uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTIxIj4xMjE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMS4wIFJDMSAtIDMxdGggSnVseSAyMDA2PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL0Zvcm1UYWJsZS5odG1sIj5Gb3JtVGFibGU8L2E+DQogICAgICAgIGRhdGEgZ3JpZCBjb250cm9sIGFuZCBhc3NvY2lhdGVkDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9GaWVsZENvbHVtbi5odG1sIj5GaWVsZENvbHVtbjwvYT4NCiAgICAgICAgY2xhc3MuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvUGFnZVN1Ym1pdC5odG1sIj5QYWdlU3VibWl0PC9hPg0KICAgICAgICBjb250cm9sIGZvciByZWRpcmVjdGluZyB0byB0YXJnZXQgcGFnZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIFBhZ2UNCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0Rm9yd2FyZChqYXZhLmxhbmcuQ2xhc3MpIj5zZXRGb3J3YXJkKENsYXNzKTwvYT4gbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZA0KICAgICAgIDxhIGhyZWY9InF1aWNrLXN0YXJ0Lmh0bWwiPlF1aWNrIFN0YXJ0PC9hPiB0b3BpYyB0byBDbGljayBkb2N1bWVudGF0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTW9kaWZpZWQgRm9ybQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNpc0Zvcm1TdWJtaXNzaW9uKCkiPmlzRm9ybVN1Ym1pc3Npb24oKTwvYT4NCiAgICAgICAgbWV0aG9kIHRvIG9ubHkgcmV0dXJuIHRydWUgaWYgdGhlIHN1Ym1pc3Npb24gaXMgZnJvbSB0aGlzIGZvcm0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMjEgLSAxOXRoIEp1bHkgMjAwNjwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MC41ZW07Ij4NCiAgICBGaW5hbCBuZXcgZmVhdHVyZXMgcmVsZWFzZSBmb3IgQ2xpY2sgMS4wLjwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBQYWdlDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svUGFnZS5odG1sI29uUmVuZGVyKCkiPm9uUmVuZGVyKCk8L2E+DQogICAgICAgbWV0aG9kLiBUaGlzIGFkZGl0aW9uIHdhcyByYWlzZWQgYnkgU3RlcGhlbiBIYWJlcm1hbg0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTA1Ij4xMDU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQXV0byBhZGQgcHVibGljIFBhZ2UgZmllbGRzIHRvIHRoZSBtb2RlbC4NCiAgICAgICBTZWUgdGhlIENsaWNrU2VydmxldCBtZXRob2RzDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ2xpY2tTZXJ2bGV0Lmh0bWwjaW5pdFBhZ2UoamF2YS5sYW5nLlN0cmluZywgamF2YS5sYW5nLkNsYXNzLCBqYXZheC5zZXJ2bGV0Lmh0dHAuSHR0cFNlcnZsZXRSZXF1ZXN0KSI+aW5pdFBhZ2UoKTwvYT4NCiAgICAgICBhbmQNCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9DbGlja1NlcnZsZXQuaHRtbCNjcmVhdGVWZWxvY2l0eUNvbnRleHQob3JnLmFwYWNoZS5jbGljay5QYWdlKSI+Y3JlYXRlVmVsb2NpdHlDb250ZXh0KCk8L2E+DQogICAgICAgZm9yIGRldGFpbHMuIFRoaXMgYWRkaXRpb24gd2FzIHJhaXNlZCBieSBTdGVwaGVuIEhhYmVybWFuDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMDkiPjEwOTwvYT4sDQogICAgICAgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTExMiI+MTEyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIFJlZmFjdG9yZWQgcGFuZWwgcGFja2FnZSB3aXRoIEJhc2ljUGFuZWwgcmVuYW1lZA0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvUGFuZWwuaHRtbCI+UGFuZWw8L2E+IGFuZCBtb3ZlZA0KICAgICAgIGludG8gdGhlIGNvcmUgY29udHJvbCBwYWNrYWdlLCBhbmQgcmVtb3ZpbmcgdGhlIFBhbmVsIGludGVyZmFjZS4NCiAgICAgICBUaGUNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3BhbmVsL0xpc3RQYW5lbC5odG1sIj5MaXN0UGFuZWw8L2E+DQogICAgICAgYW5kDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9wYW5lbC9UYWJiZWRQYW5lbC5odG1sIj5UYWJiZWRQYW5lbDwvYT4NCiAgICAgICBjbGFzc2VzIGhhdmUgYmVlbiByZXZpc2VkIHRvIHRha2UgYWR2YW50YWdlIG9mIHRoZSBuZXcgUGFuZWwgY2FwYWJpbGl0aWVzLg0KICAgICAgIDxwLz4NCiAgICAgICBQYW5lbHMgYXJlIG5vdyByZW5kZXJlZCBhcyA8dHQ+JHBhbmVsPC90dD4gcmF0aGVyIHRoYW4gPHR0PiNwYXJzZSgkcGFuZWwpPC90dD4NCiAgICAgICA8cC8+DQogICAgICAgUGFuZWxzIGNhbiBub3cgZGVmaW5lIFZlbG9jaXR5IHRlbXBsYXRlcyBvbiB0aGUgY2xhc3NwYXRoIGFzIHdlbGwgYXMgdGhlIHdlYiBmaWxlIHN5c3RlbS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQNCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL1BhZ2VMaW5rLmh0bWwiPlBhZ2VMaW5rPC9hPg0KICAgICAgIGNvbnRyb2wuIFRoaXMgYWRkaXRpb24gd2FzIHJhaXNlZCBieSBTdGVwaGVuIEhhYmVybWFuDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMDYiPjEwNjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBPR05MIHN1cHBvcnQgZm9yIHJlbmRlcmluZyA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NvbHVtbi5odG1sIj5Db2x1bW48L2E+DQogICAgICAgdmFsdWVzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBtdWx0aXBsZSBBY3Rpb25MaW5rIHBhcmFtZXRlcnMsIHNlZQ0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWJzdHJhY3RMaW5rLmh0bWwjc2V0UGFyYW1ldGVyKGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5TdHJpbmcpIj5zZXRQYXJhbWV0ZXIoKTwvYT4NCiAgICAgICBmb3IgZGV0YWlscy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgTWVudQ0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9NZW51Lmh0bWwjaXNVc2VySW5Sb2xlcygpIj5pc1VzZXJJblJvbGVzKCk8L2E+DQogICAgICAgbWV0aG9kLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZA0KICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA1Lmh0bWwiPkJlc3QgUHJhY3RpY2VzPC9hPiB0b3BpYyB0byBDbGljaw0KICAgICAgIGRvY3VtZW50YXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIFRvbWNhdCBkZXBsb3ltZW50IGlzc3VlIHdoZXJlIFRvbWNhdCBDbGFzc0xvYWRlciB3YXMgbG9ja2luZyBDbGljaw0KICAgICAgIEpBUnMgcHJldmVudGluZyBhcHBsaWNhdGlvbiByZWRlcGxveW1lbnQuIER1ZSBsb2NraW5nIG9uIFVSTCBzdHJlYW1zLA0KICAgICAgIHRoZSBkZXBsb3ltZW50IHRlY2huaXF1ZSBoYXMgcmV2ZXJ0ZWQgYmFjayB0byB1c2luZyB1bmlxdWVseSBuYW1lZCBmaWxlcyAocHJlIDAuMTkpLg0KICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEb3ljaGkNCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTgyIj44MjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBGaXhlZCBNZXNzYWdlc01hcCBjYWNoZSBwZXJtaXNzaW9ucyBpc3N1ZS4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBEYXZpZCBGZWxpcw0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstOTkiPjk5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIEZpZWxkIHNldEZvY3VzKCkgYnVnLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IERhdmlkIEZlbGlzDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMDIiPjEwMjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBGaXhlZCBDb250ZXh0IHNlc3Npb24gTG9jYWxlIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBTdGV2ZW4gVmFuIEhvb2YNCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTEwNyI+MTA3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIFNlbGVjdCB2YWxpZGF0aW9uIGJ1ZyB3aGVuIG5vIG9wdGlvbnMgYXJlIGRlZmluZWQuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgRGF2aWQgRnJpemVsbGUNCiAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTExMCI+MTEwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIERvdWJsZUZpZWxkIHZhbGlkYXRpb24gYnVnIHdpdGggIjAiIHZhbHVlLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IERhdmlkIEZyaXplbGxlDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMTEiPjExMTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBNb3ZlZCBBY3Rpb25CdXR0b24gY29udHJvbCBmcm9tIENsaWNrIEV4dHJhcyB0byBjb3JlIGNvbnRyb2xzIHBhY2thZ2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIFJlbW92ZWQgZGVwcmVjaWF0ZWQgQ29udGV4dCBzZXNzaW9uT2JqZWN0IG1ldGhvZHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMjAgLSA3dGggSnVuZSAyMDA2PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBjbGllbnQgc2lkZSBKYXZhU2NyaXB0DQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjZm9ybS12YWxpZGF0aW9uIj5Gb3JtIFZhbGlkYXRpb248L2E+DQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xNiI+MTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgbmV3IENsaWNrIGV4dHJhcyBjb250cm9scw0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9DaGVja0xpc3QuaHRtbCI+Q2hlY2tMaXN0PC9hPiBhbmQNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvQ29sb3JQaWNrZXIuaHRtbCI+Q29sb3JQaWNrZXI8L2E+Lg0KICAgICAgIFRoZXNlIGNvbnRyb2xzIHdlcmUgYWRkZWQgYnkgQ2hyaXN0aWFuIEVzc2VsDQogICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy04MSI+ODE8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBhIGdsb2JhbCBwYWdlIG1lc3NhZ2UgYnVuZGxlLCBzZWUgUGFnZQ0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNnZXRNZXNzYWdlKGphdmEubGFuZy5TdHJpbmcpIj5nZXRNZXNzYWdlKCk8L2E+DQogICAgICAgZm9yIGRldGFpbHMuIFRoaXMgaXNzdWUgcmFpc2VkIGJ5IENsYXVkaW8gUm9zc2V0dG8NCiAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzIiPjcyPC9hPl0uDQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sIj5Db250cm9sPC9hPg0KICAgICAgIDx0dD5wYXJlbnQ8L3R0PiBwcm9wZXJ0eQ0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstODgiPjg4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIHN1cHBvcnQgdGFibGUgQ29sdW1uIHN1cHBvcnQgZm9yIDx0dD5qYXZhLnV0aWwuTWFwPC90dD4gcm93IG9iamVjdHMuDQogICAgICAgVGhpcyBpc3N1ZSByYWlzZWQgYnkgSi5GLiBaYXJhbWENCiAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstOTEiPjkxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIG9wdGlvbiB0byBwbGFjZSBUYWJsZSBiYW5uZXIgb24gdG9wLg0KICAgICAgIFNlZSBUYWJsZQ0KICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvVGFibGUuaHRtbCNiYW5uZXJQb3NpdGlvbiI+YmFubmVyUG9zaXRpb248L2E+DQogICAgICAgSmF2YWRvYyBmb3IgZGV0YWlscy4gVGhpcyBpc3N1ZSByYWlzZWQgYnkgSi5GLiBaYXJhbWENCiAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstOTIiPjkyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZCBjb25maWd1cmFibGUgYXBwbGljYXRpb24gTG9jYWxlLiBTZWUNCiAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2NsaWNrLWFwcCI+Q2xpY2sgQXBwPC9hPiBmb3INCiAgICAgICBkZXRhaWxzIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy05NiI+OTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgJ1BhZ2UnIHN1ZmZpeCB3aGVuIGF1dG9tYXBwaW5nIHBhdGggLT4gY2xhc3NuYW1lLg0KICAgICAgIFNlZSA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2FwcGxpY2F0aW9uLWF1dG9tYXBwaW5nIj5hdXRvbWFwcGluZzwvYT4NCiAgICAgICB0b3BpYyBmb3IgZGV0YWlscy4gVGhpcyBpc3N1ZSByYWlzZWQgYnkgU3RlcGhlbiBIYWJlcm1hbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgUGFnZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0UmVkaXJlY3QoamF2YS5sYW5nLkNsYXNzKSI+c2V0UmVkaXJlY3QocGFnZUNsYXNzKTwvYT4NCiAgICAgICBtZXRob2QuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIEZvcm1hdCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0Zvcm1hdC5odG1sI2N1cnJlbnREYXRlKCkiPmN1cnJlbnREYXRlKCk8L2E+DQogICAgICAgbWV0aG9kcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgcmVxdWVzdCBwYXJhbWV0ZXIgdG8gQ2xpY2tTZXJ2bGV0DQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ2xpY2tTZXJ2bGV0Lmh0bWwjbmV3UGFnZUluc3RhbmNlKGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5DbGFzcywgamF2YXguc2VydmxldC5odHRwLkh0dHBTZXJ2bGV0UmVxdWVzdCkiPm5ld1BhZ2VJbnN0YW5jZSgpPC9hPg0KICAgICAgIG1ldGhvZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgQnJhemlsaWFuIHByb3BlcnRpZXMgZmlsZXMgcHJvdmlkZWQgYnkNCiAgICAgICBSaWNhcmRvIExlY2hldGEgWzxhIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTg2Ij44NjwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBBZGRlZCA8YSB0YXJnZXQ9ImJsYW5rIiBjbGFzcz0iZXh0ZXJuYWwiIGhyZWY9Imh0dHA6Ly9jYXllbm5lLmFwYWNoZS5vcmcvIj5DYXllbm5lPC9hPg0KICAgICAgIGludGVncmF0aW9uIGV4YW1wbGUgdG8gRXhhbXBsZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIDxhIHRhcmdldD0iYmxhbmsiIGNsYXNzPSJleHRlcm5hbCIgaHJlZj0iaHR0cDovL3d3dy5zcHJpbmdzb3VyY2Uub3JnLyI+U3ByaW5nPC9hPg0KICAgICAgIGludGVncmF0aW9uIGV4YW1wbGUgdG8gRXhhbXBsZXMgYW5kIGltcHJvdmVkDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9zcHJpbmcvU3ByaW5nQ2xpY2tTZXJ2bGV0Lmh0bWwiPlNwcmluZ0NsaWNrU2VydmxldDwvYT4NCiAgICAgICBkb2N1bWVudGF0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBJbXByb3ZlZCBWZWxvY2l0eSByZW5kZXJpbmcgcGVyZm9ybWFuY2UuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYW5kDQogICAgICAgZml4ZWQgYnkgU3RlcGhlbiBIYWJlcm1hbg0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0naHR0cDovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL1ZFTE9DSVRZLTQzOCc+VkVMT0NJVFktNDM4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEltcHJvdmVkDQogICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9IdG1sU3RyaW5nQnVmZmVyLmh0bWwiPkh0bWxTdHJpbmdCdWZmZXI8L2E+DQogICAgICAgcGVyZm9ybWFuY2Ugd2l0aCB1bnN5bmNocm9uaXplZCBhcHBlbmQgbWV0aG9kcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgSW1wcm92ZWQgQ1NTIGxpbmsgcmVuZGVyaW5nIHRvIGVuYWJsZSBhbHRlcm5hdGUgc3R5bGUgc2hlZXRzLiBUaGlzDQogICAgICAgaXNzdWUgd2FzIHJhaXNlZCBieSBFbnJpY28gRG9uZWxsaQ0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstODEiPjgxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEZpeGVkIDx0dD5VbnN1cHBvcnRlZEVuY29kaW5nRXhjZXB0aW9uPC90dD4gaW4gQ2xpY2tVdGlscy5lbmNvZGVVcmwoKSB3aGVuDQogICAgICAgYXBwbGljYXRpb24gY2hhcnNldCBpcyB1bmRlZmluZWQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy04NyI+ODc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgRml4ZWQgZmlsZSBkZXBsb3ltZW50IGlzc3VlIG9uIHNlcnZlcnMgd2l0aCByZXN0cmljdGVkIHBlcm1pc3Npb25zLg0KICAgICAgIFRoaXMgaXNzdWUgd2FzIHJhaXNlZCBieSBEYXZpZCBGZWxpcw0KICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstOTUiPjk1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpPg0KICAgICAgIFJlbW92ZWQgQ29udHJvbCA8dHQ+cGFyZW50TWVzc2FnZXM8L3R0PiBwcm9wZXJ0eSB3aGljaCB3YXMgZWZmZWN0aXZlbHkNCiAgICAgICByZXBsYWNlZCBieSBuZXcgPHR0PnBhcmVudDwvdHQ+IGFuZCA8dHQ+bWVzc2FnZXM8L3R0PiBwcm9wZXJ0aWVzLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBSZW1vdmVkIEZvcm0gc3VwcG9ydCBmb3IgU3RydXRzIHN0eWxlIGVycm9yIG1lc3NhZ2UgcmVuZGVyaW5nLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBVcGRhdGVkIFZlbG9jaXR5IDEuNS1kZXYgSkFSIHNuYXBzaG90IHRvIHJldmlzaW9uIDM5MDczNSwgd2l0aA0KICAgICAgIHBhdGNoIFZFTE9DSVRZLTQzOCBhcHBsaWVkLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICBVcGRhdGVkIHBhY2thZ2luZzogPHR0PmNsaWNrLWRvY3VtZW50YXRpb24ud2FyPC90dD4gcmVwbGFjZWQgYnkNCiAgICAgICAgPHR0PmRvY3VtZW50YXRpb248L3R0PiBkaXJlY3RvcnkgYW5kIDx0dD53ZWJhcHBzL2NsaWNrLWV4YW1wbGVzPC90dD4NCiAgICAgICAgbW92ZWQgdG8gPHR0PmV4YW1wbGVzPC90dD4gZGlyZWN0b3J5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjE5IC0gOHRoIEFwcmlsIDIwMDY8L2R0Pg0KICA8ZGQ+DQogICAgPGRpdiBzdHlsZT0ibWFyZ2luLWxlZnQ6LTJlbTttYXJnaW4tYm90dG9tOjAuNWVtOyI+IE5ldyBkZXZlbG9wZXINCiAgICA8YSB0YXJnZXQ9ImJsYW5rIiBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3VzZXJzL2NocmlzaWNocmlzLyI+Q2hyaXN0aWFuIEVzc2w8L2E+DQogICAgam9pbnMgdGhlIENsaWNrIHByb2plY3QuPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIE5ldyA8YSBocmVmPSJodHRwOi8vd3d3LnN1bnZvbHQuY29tL2NvbmZsdWVuY2UvZGlzcGxheS9DTEtUL0NsaWNrSURFIj5DbGlja0lERTwvYT4NCiAgICAgICBFY2xpcHNlIFdUUCBwbHVnLWluIHJlbGVhc2VkIGJ5IE5hb2tpIFRha2V6b2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIG5ldyBDbGljayBFeHRyYXMgY29udHJvbHMNCiAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0FjdGlvbkJ1dHRvbi5odG1sIj5BY3Rpb25CdXR0b248L2E+LA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9Mb25nRmllbGQuaHRtbCI+TG9uZ0ZpZWxkPC9hPiwNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTnVtYmVyRmllbGQuaHRtbCI+TnVtYmVyRmllbGQ8L2E+LA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9UYWJiZWRGb3JtLmh0bWwiPlRhYmJlZEZvcm08L2E+IGFuZA0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9UZWxlcGhvbmVGaWVsZC5odG1sIj5UZWxlcGhvbmVGaWVsZDwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgIEFkZGVkIG5ldyBDbGljayBFeHRyYXMgQ2F5ZW5uZSBjb250cm9scw0KICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9Qcm9wZXJ0eVNlbGVjdC5odG1sIj5Qcm9wZXJ0eVNlbGVjdDwvYT4sDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL1F1ZXJ5U2VsZWN0Lmh0bWwiPlF1ZXJ5U2VsZWN0PC9hPiBhbmQNCiAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NheWVubmUvVGFiYmVkQ2F5ZW5uZUZvcm0uaHRtbCI+VGFiYmVkQ2F5ZW5uZUZvcm08L2E+Lg0KICAgICAgIEFsc28gYWRkZWQgd2ViDQogICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL0RhdGFDb250ZXh0RmlsdGVyLmh0bWwiPkRhdGFDb250ZXh0RmlsdGVyPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIENvbnRleHQgcGFnZSBwYXRoIGxvb2t1cCBtZXRob2QNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI2dldFBhZ2VQYXRoKGphdmEubGFuZy5DbGFzcykiPmdldFBhZ2VQYXRoKCk8L2E+Lg0KICAgICAgICBUaGlzIGZlYXR1cmUgd2FzIHN1Z2dlc3RlZCBieSBDaHJpc3RpYW4gRXNzbA0KICAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjgiPjY4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBzdXBwb3J0IGZvcg0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNkYXRhLWJpbmRpbmciPmRhdGEgYmluZGluZzwvYT4NCiAgICAgICAgb2YgbmVzdGVkIG9iamVjdHMgaW4gZm9ybSBmaWVsZHMgdXNpbmcNCiAgICAgICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3d3dy5vZ25sLm9yZyI+T0dOTDwvYT4gbGlicmFyeS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIEZvcm0gYnV0dG9uU3R5bGUsIGZpZWxkU3R5bGUgYW5kIGxhYmVsU3R5bGUgYXR0cmlidXRlcyB0byBzdXBwb3J0DQogICAgICAgIGN1c3RvbWlzZWQgZm9ybQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNhdXRvLWxheW91dCI+YXV0byBsYXlvdXRzPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIENvbnRyb2wgVmVsb2NpdHkgdGVtcGxhdGVzIHVzaW5nIG5ldyBDb250ZXh0DQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNyZW5kZXJUZW1wbGF0ZShqYXZhLmxhbmcuQ2xhc3MsIGphdmEudXRpbC5NYXApIj5yZW5kZXJUZW1wbGF0ZSgpPC9hPg0KICAgICAgICBtZXRob2RzLiBTZWUgQ2xpY2sgRXhhbXBsZXMgJ1JpY2ggVGV4dCBBcmVhJyBhbmQgJ1RhYmJlZCBGb3JtJyBmb3INCiAgICAgICAgZGVtb25zdHJhdGlvbnMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBwYWdlIGF1dG9tYXBwaW5nDQogICAgICAgIDxhIGhyZWY9InVzZXItZ3VpZGUvaHRtbC9jaDA0czAyLmh0bWwjYXBwbGljYXRpb24tZXhjbHVkZXMiPmV4Y2x1ZGVzPC9hPi4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBBaG1lZCBNb2hvbWJlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTIiPjUyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBUYWJsZSBjb250cm9sIG1vdXNlb3ZlciByb3cgaGlnaGxpZ2h0Lg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5IEFobWVkIE1vaG9tYmUgYW5kIHJlc29sdmVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTciPjU3PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXM9ImNoYW5nZSI+DQogICAgICAgQWRkZWQgRnJlbmNoIGFuZCBJdGFsaWFuIHByb3BlcnRpZXMgZmlsZXMgcHJvdmlkZWQgYnkNCiAgICAgICBMb3JlbnpvIE9yc2VsbGkgWzxhIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTY1Ij42NTwvYT4sDQogICAgICAgPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjYiPjY2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NwcmluZy9TcHJpbmdDbGlja1NlcnZsZXQuaHRtbCI+U3ByaW5nQ2xpY2tTZXJ2bGV0PC9hPg0KICAgICAgICBjb25maWd1cmF0aW9uIG9wdGlvbnMgYW5kIGRvY3VtZW50YXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0Zvcm1hdC5odG1sIj5Gb3JtYXQ8L2E+DQogICAgICAgIGNsYXNzIG5vdyB1c2VzIHJlcXVlc3QgY29udGV4dCBMb2NhbGUuDQogICAgICAgIFBsZWFzZSBub3RlIHRoaXMgY2hhbmdlIHJlcXVpcmVzIG1vZGlmaWNhdGlvbiB0byBGb3JtYXQgc3ViY2xhc3MNCiAgICAgICAgY29uc3RydWN0b3JzLg0KICAgICAgICBUaGlzIGlzc3VlIHdhcyByYWlzZWQgYnkgQ2hyaXN0aWFuIEVzc2wNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03OSI+Nzk8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgVmVsb2NpdHkgbGlicmFyeSB0byBsYXRlc3QgMS41LWRldiBidWlsZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgQ2F5ZW5uZSBsaWJyYXJ5IHRvIHZlcnNpb24gMS4yQjEuDQogICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL0NheWVubmVGb3JtLmh0bWwiPkNheWVubmVGb3JtPC9hPg0KICAgICAgICBkdXBsaWNhdGUgaW5zZXJ0IGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieQ0KICAgICAgICBCb2IgU2NoZWxsaW5rIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy02MyI+NjM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRGF0ZUZpZWxkIGludGVybmF0aW9uYWxpemF0aW9uIGJ1Zy4gSXNzdWUgaWRlbnRpZmllZCBieQ0KICAgICAgICBMb3JlbnpvIE9yc2VsbGkgYW5kIGZpeCBwcm92aWRlZCBieSAgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNjAiPjYwPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXM9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIENsaWNrVXRpbHMgaW52b2tlTGlzdGVuZXIgb24gYW5vbnltb3VzIGlubmVyIGNsYXNzZXMgYnVnLg0KICAgICAgICBUaGlzIGlzc3VlIGlkZW50aWZpZWQgYW5kIGZpeGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy03NyI+Nzc8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIEFjdGlvbkxpbmsgcGFyYW1ldGVyIGVuY29kaW5nIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieQ0KICAgICAgICBTdGV2ZW4gVmFuIEhvb2YgYW5kIGZpeGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNzgiPjc4PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZW1vdmVkIGV4YW1wbGUgPHR0PmNsaWNrLWJsYW5rPC90dD4gYW5kIDx0dD5jbGljay1jYXllbm5lPC90dD4gYXBwbGljYXRpb25zDQogICAgICAgIGZyb20gbWFpbiBkaXN0cmlidXRpb24uIFRoZXNlIGV4YW1wbGVzIHdpbGwgYmUgcmVsZWFzZWQgYXMgc2VwYXJhdGUNCiAgICAgICAgcGFja2FnZXMgdW5kZXIgc291cmNlZm9yZ2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMTggLSAxNXRoIEphbnVhcnkgMjAwNjwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MC41ZW07Ij4gTmV3IGRldmVsb3Blcg0KICAgIDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdXNlcnMvdGFrZXpvZS8iPk5hb2tpIFRha2V6b2U8L2E+DQogICAgam9pbnMgdGhlIENsaWNrIHByb2plY3QuPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBDcmVhdGVkIG5ldyBwYWNrYWdlDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9wYWNrYWdlLXN1bW1hcnkuaHRtbCI+b3JnLmFwYWNoZS5jbGljay5leHRyYXMuY29udHJvbDwvYT4NCiAgICAgICAgZm9yIGV4dGVuZGVkIEhUTUwgY29udHJvbHMuIFRoZSBmb2xsb3dpbmcgY29udHJvbHMgaGF2ZSBiZWVuIG1vdmVkDQogICAgICAgIGludG8gdGhpcyBwYWNrYWdlOiBDcmVkaXRDYXJkRmllbGQsIERhdGVGaWVsZCwgRG91YmxlRmllbGQsIEVtYWlsRmllbGQsDQogICAgICAgIEludGVnZXJGaWVsZCBhbmQgTWVudS4NCiAgICAgICAgPHAvPg0KICAgICAgICBUYWJsZSBjb250cm9sIHByb21vdGVkIHRvIGNvcmUgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9wYWNrYWdlLXN1bW1hcnkuaHRtbCI+b3JnLmFwYWNoZS5jbGljay5jb250cm9sPC9hPi4NCiAgICAgICAgPHAvPg0KICAgICAgICBBZGRlZCBDb250cm9sIG1ldGhvZHMNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI2dldEh0bWxJbXBvcnRzKCkiPmdldEh0bWxJbXBvcnRzKCk8L2E+IGFuZA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250cm9sLmh0bWwjb25EZXBsb3koamF2YXguc2VydmxldC5TZXJ2bGV0Q29udGV4dCkiPm9uRGVwbG95KCk8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9QYWdlSW1wb3J0cy5odG1sIj5QYWdlSW1wb3J0czwvYT4NCiAgICAgICAgb2JqZWN0IHRvIGF1dG9tYXRpY2FsbHkgcmVuZGVyIGNvbnRyb2wgSFRNTCBoZWFkZXIgaW1wb3J0cy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGZvcm0gYmFjayBidXR0b24gc3VwcG9ydC4gU2VlIEZvcm0NCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjb25TdWJtaXRDaGVjayhvcmcuYXBhY2hlLmNsaWNrLlBhZ2UsIGphdmEubGFuZy5TdHJpbmcpIj5vblN1Ym1pdENoZWNrKCk8L2E+DQogICAgICAgIEFQSSBmb3IgZGV0YWlscy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIGZ1bGwgSlNQIENsaWNrIFBhZ2UgaW50ZWdyYXRpb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNCI+MjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9SZWdleEZpZWxkLmh0bWwiPlJlZ2V4RmllbGQ8L2E+DQogICAgICAgIHByb3ZpZGVkIGJ5IE5hb2tpIFRha2V6b2UNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00NiI+NDY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY2F5ZW5uZS9Qcm9wZXJ0eVNlbGVjdC5odG1sIj5Qcm9wZXJ0eVNlbGVjdDwvYT4NCiAgICAgICAgcHJvdmlkZWQgYnkgQWhtZWQgTW9ob21iZS4gUGxlYXNlIHNlZSBDbGljayBDYXllbm5lIHdlYiBhcHBsaWNhdGlvbiBmb3INCiAgICAgICAgYSBkZW1vbnN0cmF0aW9uLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgSmFwYW5lc2UgbWVzc2FnZSByZXNvdXJjZXMgcHJvdmlkZWQgYnkgTmFva2kgVGFrZXpvZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ0Ij40NDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgR2VybWFuIG1lc3NhZ2UgcmVzb3VyY2VzIHByb3ZpZGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTUiPjU1PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBjbGljay1leGFtcGxlcyBUYWJsZSB3aXRoIEZvcm0gZmllbGRzIGRlbW9uc3RyYXRpb24gcHJvdmlkZWQgYnkNCiAgICAgICAgQ2hyaXN0aWFuIEVzc2wuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBVVEYtOCBjaGFyc2V0IGhhbmRsaW5nIHByb3ZpZGVkIGJ5IE5hb2tpIFRha2V6b2UNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01NiI+NTY8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIEZvcm0gJmx0Oy0mZ3Q7IERBTyAgYXV0by1sb2FkaW5nIHRvIGhhbmRsZSBwcmltaXRpdmUgdHlwZXMuDQogICAgICAgIFByb3ZpZGVkIGJ5IENocmlzdGlhbiBFc3NsDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNTMiPjUzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBVcGRhdGVkIGNvbW1vbnMtZmlsZXVwbG9hZCB0byB2ZXJzaW9uIDEuMSBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ5Ij40OTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgbnVsbCBDb2x1bW4gRGVjb3JhdG9yIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBHZW9mZiBIb3Bzb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00MCI+NDA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFRhYmxlIHBhZ2luZyBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgQWhtZWQgTW9ob21iZQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQxIj40MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgVGV4dEZpZWxkIGNvbnN0cnVjdG9yIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBCb2IgU2NoZWxsaW5rDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDIiPjQyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBKU0NhbGVuZGFyIHByb2JsZW0gaW4gSmFwYW5lc2UuIFRoaXMgZml4IHdhcyBwcm92aWRlZCBieQ0KICAgICAgICBOYW9raSBUYWtlem9lDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstNDMiPjQzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBGb3JtIEZpZWxkU2V0IEZpbGVGaWVsZCBlbmN0eXBlIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieQ0KICAgICAgICBDaHJpc3RpYW4gRXNzbA0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTQ4Ij40ODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgc2Vzc2lvbiByZXdyaXRlIGJ1ZyB3aGVuIHVzaW5nIGFic29sdXRlIHJlZGlyZWN0cy4NCiAgICAgICAgVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieSBNYWlrIEphYmxvbnNraQ0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTUxIj41MTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgVmVsb2NpdHkgUnVudGltZUV4Y2VwdGlvbiBoYW5kbGluZyBidWcNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvVkVMT0NJVFktNDI0Ij5WRUxPQ0lUWS00MjQ8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIFZlbG9jaXR5IDEuNS1kZXYgYW5kIENheWVubmUgMS4yIGludGVyb3BlcmFiaWxpdHkgYnVnDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cDovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL1ZFTE9DSVRZLTQyNiI+VkVMT0NJVFktNDI2PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMTcgLSA1dGggRGVjZW1iZXIgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIE1vZGlmaWVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NsaWNrU2VydmxldC5odG1sIj5DbGlja1NlcnZsZXQ8L2E+DQogICAgICAgIHRvIGVuYWJsZSBkaXJlY3QgU2VydmxldFJlc3BvbnNlIGhhbmRsaW5nIGJ5DQogICAgICAgIFBhZ2VzLiBTZWUgQ2xpY2sgRXhhbXBsZXMgRGlyZWN0IFBhZ2UgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIE1vZGlmaWVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvc3ByaW5nL1NwcmluZ0NsaWNrU2VydmxldC5odG1sIj5TcHJpbmdDbGlja1NlcnZsZXQ8L2E+DQogICAgICAgIHRvIHNldCBTcHJpbmcgQXBwbGljYXRpb25Db250ZXh0IGluIHBhZ2VzIGltcGxlbWVudGluZw0KICAgICAgICA8dHQ+QXBwbGljYXRpb25Db250ZXh0QXdhcmU8L3R0PiBpbnRlcmZhY2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDbGljayAwLjE2IGludGVncmF0aW9uIGlzc3VlcyB3aXRoIFZlbG9jaXR5IDEuNS1kZXYgc25hcHNob3QgYW5kDQogICAgICAgIENheWVubmUgMS4yLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgUmVnaXN0ZXJlZCBDbGljayBKQVJzIHdpdGgNCiAgICAgICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3d3dy5pYmlibGlvLm9yZy9tYXZlbi9uZXQuc2YuY2xpY2svamFycy8iPkliaWJsaW8gTWF2ZW48L2E+IFJlcG9zaXRvcnkuDQogICAgICA8L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4xNiAtIDJuZCBEZWNlbWJlciAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgY29udHJvbCBsb2NhbGl6YXRpb24gc3VwcG9ydCwgcGxlYXNlIHNlZQ0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwjZ2V0TGFiZWwoKSI+RmllbGQ8L2E+DQogICAgICAgIEphdmFkb2MgYW5kIDxhIGhyZWY9ImZhcS5odG1sI2xvY2FsaXphdGlvbiI+RkFRPC9hPiBmb3IgZGV0YWlscy4NCiAgICAgICAgPHAvPg0KICAgICAgICBUaGlzIGZlYXR1cmUgYmFzZWQgb24gYSBjb25jZXB0IGRldmVsb3BlZCBieSBBaG1lZCBNb2hvbWJlLA0KICAgICAgICBhbmQgcmVwbGFjZXMgdGhlIDx0dD4ibXNnOiI8L3R0PiBwcmVmaXggbG9jYWxpemF0aW9uIGZ1bmN0aW9uYWxpdHkNCiAgICAgICAgaW50cm9kdWNlZCBpbiByZWxlYXNlIDAuMTMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBIaWJlcm5hdGUgZGF0YSBhd2FyZSBGb3JtIGNvbnRyb2wNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9oaWJlcm5hdGUvSGliZXJuYXRlRm9ybS5odG1sIj5IaWJlcm5hdGVGb3JtPC9hPiwNCiAgICAgICAgYW5kIHN1cHBvcnRpbmcNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9oaWJlcm5hdGUvU2Vzc2lvbkNvbnRleHQuaHRtbCI+U2Vzc2lvbkNvbnRleHQ8L2E+IGFuZA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2hpYmVybmF0ZS9TZXNzaW9uRmlsdGVyLmh0bWwiPlNlc3Npb25GaWx0ZXI8L2E+IGNsYXNzZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBNZW51DQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvY29udHJvbC9NZW51Lmh0bWwjcGFnZXMiPnBhZ2VzPC9hPg0KICAgICAgICBwcm9wZXJ0eSBmb3Igc2VsZWN0aW5nIG1lbnUgaXRlbXMuIFRoaXMgZmVhdHVyZSB3YXMgcHJvdmlkZWQgYnkNCiAgICAgICAgR2VvZmYgSG9wc29uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzkiPjM5PC9hPl0uDQogICAgICAgIDxwLz4NCiAgICAgICAgUmVmYWN0b3JlZCA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvTWVudS5odG1sIj5NZW51PC9hPg0KICAgICAgICB0byBpbXBsZW1lbnQgQ29udHJvbCBpbnRlcmZhY2UgdG8gaW1wcm92ZSBQYWdlIHN1YmNsYXNzaW5nLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgSW1wcm92ZWQgRm9ybSByZW5kZXJpbmcgZmxleGliaWxpdHkgd2l0aCBuZXcgcHJvcGVydGllcw0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNnZXRMYWJlbFJlcXVpcmVkUHJlZml4KCkiPmxhYmVsUmVxdWlyZWRQcmVmaXg8L2E+DQogICAgICAgIGFuZA0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNnZXRMYWJlbFJlcXVpcmVkU3VmZml4KCkiPmxhYmVsUmVxdWlyZWRTdWZmaXg8L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9TZWxlY3QuaHRtbCNzZXRNdWx0aXBsZVZhbHVlcyhqYXZhLnV0aWwuTGlzdCkiPlNlbGVjdDwvYT4NCiAgICAgICAgPHR0PnNldE11bHRpcGxlVmFsdWVzKCk8L3R0PiBtZXRob2QuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkNCiAgICAgICAgR2VvZmYgSG9wc29uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzQiPjM0PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBDb250ZXh0DQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL0NvbnRleHQuaHRtbCNjcmVhdGVQYWdlKGphdmEubGFuZy5DbGFzcykiPmNyZWF0ZVBhZ2UoKTwvYT4NCiAgICAgICAgbWV0aG9kIGVuYWJsaW5nIHlvdSB0byBzcGVjaWZ5IHRoZSB0YXJnZXQgcGFnZSBieSBjbGFzcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+QWRkZWQgY3VzdG9tIHJpY2ggdGV4dCBhcmVhIGNvbnRyb2wgZGVtb25zdHJhdGlvbg0KICAgICAgICBpbiBDbGljayBFeGFtcGxlcyBFbWFpbCBGb3JtIHBhZ2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBDb2x1bW4gbnVsbCB2YWx1ZSBoYW5kbGluZyBidWcuIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkNCiAgICAgICAgR2VvZmYgSG9wc29uDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMzIiPjMyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBBY3Rpb25MaW5rIHZhbHVlIGVzY2FwaW5nIGJ1Zy4gVGhpcyBpc3N1ZSB3YXMgaWRlbnRpZmllZCBieQ0KICAgICAgICBHZW9mZiBIb3Bzb24NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zMyI+MzM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIERhdGVGaWVsZCBJMThOIGlzc3VlIGFuZCBpbXByb3ZlZCByZW5kZXJpbmcuIFRoZXNlIGlzc3VlcyB3ZXJlDQogICAgICAgIGlkZW50aWZpZWQgYnkgQW50b25pIEFsb3kgYW5kIEFobWVkIE1vaG9tYmUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zNiI+MzY8L2E+LA0KICAgICAgICAgPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTI3Ij4yNzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTW9kaWZpZWQgRm9ybWF0DQogICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvRm9ybWF0Lmh0bWwjZ2V0RW1wdHlTdHJpbmcoKSI+Z2V0RW1wdHlTdHJpbmcoKTwvYT4NCiAgICAgICAgdG8gcmV0dXJuICIiIHN0cmluZ3MgdG8gYmV0dGVyIHN1cHBvcnQgQUpBWCByZW5kZXJpbmcuDQogICAgICAgIFRoaXMgaXNzdWUgd2FzIGlkZW50aWZpZWQgYnkgQW5kcnVzIEFkYW1jaGlrLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjE1IC0gMjV0aCBPY3RvYmVyIDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBlc2NhcGluZyBxdW90ZSBjaGFyYWN0ZXJzIGluIGNvbnRyb2xzLiBUaGlzIGlzc3VlIHdhcyBpZGVudGlmaWVkIGJ5DQogICAgICAgIE1pa2UgT3JnYW5law0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMxIj4zMTwvYT5dLjxici8+DQogICAgICAgIEFkZGVkIG5ldw0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0h0bWxTdHJpbmdCdWZmZXIuaHRtbCI+SHRtbFN0cmluZ0J1ZmZlcjwvYT4NCiAgICAgICAgY2xhc3MgZm9yIGNvbnRyb2wgcmVuZGVyaW5nLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgY2xpY2stY2F5ZW5uZSA8YSBocmVmPSJleGFtcGxlcy5odG1sIj5leGFtcGxlPC9hPiB3ZWIgYXBwbGljYXRpb24uDQogICAgICAgIFRoaXMgYXBwbGljYXRpb24gd2FzIGNvbnRyaWJ1dGVkIGJ5IEFuZHJ1cyBBZGFtY2hpay4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlZmFjdG9yZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwiPkZvcm08L2E+DQogICAgICAgIGFsaWduIGFuZCBwb3NpdGlvbiBjb25zdGFudHMgdG8gcmVtb3ZlIGFtYmlndWl0eS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIENsaWNrQXBwIE5QRSB3aGVuIGluaXRpYWxpemluZw0KICAgICAgICBbPGEgdGFyZ2V0PSdfYmxhbmsnIGhyZWY9Imh0dHBzOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvQ0xLLTMwIj4zMDwvYT5dLA0KICAgICAgICByZWxhdGVkIFZlbG9jaXR5IEVuZ2luZSBwYXRjaGVzIGFwcGxpZWQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvVkVMT0NJVFktNDEyIj40MTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlZmFjdG9yZWQgQW50IGJ1aWxkIHN5c3RlbS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxkdD5WZXJzaW9uIDAuMTQgLSAxN3RoIE9jdG9iZXIgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tbGVmdDotMmVtO21hcmdpbi1ib3R0b206MC41ZW07Ij4gTmV3IGRldmVsb3Blcg0KICAgIDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdXNlcnMvYW1vaG9tYmUvIj5BaG1lZCBNb2hvbWJlPC9hPg0KICAgIGpvaW5zIHRoZSBDbGljayBwcm9qZWN0LjwvZGl2Pg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgRml4ZWQgRmllbGRTZXQgRm9ybSBwcm9jZXNzaW5nIGJ1Zy4gVGhlIGJ1ZyB3YXMgaWRlbnRpZmllZCBieSBieSBQYXVsIFJ1bGUNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yNSI+MjU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFJlbW92ZWQgSkRPTSBkZXBlbmRlbmN5Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgVmVsb2NpdHkgRW5naW5lIGVycm9yIHJlcG9ydGluZyBwYXRjaGVzIGFwcGxpZWQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vaXNzdWVzLmFwYWNoZS5vcmcvamlyYS9icm93c2UvVkVMT0NJVFktMzczIj4zNzM8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIE1vZGlmaWVkIEFudCBidWlsZCBzY3JpcHQgdG8gZG93bmxvYWQgSkFSIGRlcGVuZGVuY2llcyBmcm9tDQogICAgICAgIDxhIGhyZWY9Imh0dHA6Ly93d3cuaWJpYmxpby5vcmcvbWF2ZW4vIj5JYmlibGlvPC9hPiBNYXZlbiByZXBvc2l0b3J5Lg0KICAgICAgPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8ZHQ+VmVyc2lvbiAwLjEzIC0gMTN0aCBPY3RvYmVyIDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCBTcHJpbmcgaW50ZWdyYXRpb24gc2VydmxldA0KICAgICAgICA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL3NwcmluZy9TcHJpbmdDbGlja1NlcnZsZXQuaHRtbCI+U3ByaW5nQ2xpY2tTZXJ2bGV0PC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEFkZGVkIENheWVubmUgZGF0YSBhd2FyZSBGb3JtIGNvbnRyb2wNCiAgICAgICAgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jYXllbm5lL0NheWVubmVGb3JtLmh0bWwiPkNheWVubmVGb3JtPC9hPi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEltcHJvdmVkIEpTUCBzdXBwb3J0LiBTZWUNCiAgICAgICAgPGEgaHJlZj0iZmFxLmh0bWwjanNwLXN1cHBvcnQiPkZBUTwvYT4NCiAgICAgICAgZm9yIGRldGFpbHMgYW5kIENsaWNrIEV4YW1wbGVzIGZvciBhIGRlbW9uc3RyYXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZA0KCTxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGQuaHRtbCNzZXRMYWJlbChqYXZhLmxhbmcuU3RyaW5nKSI+RmllbGQ8L2E+DQoJbG9jYWxpemF0aW9uIHN1cHBvcnQsIHNlZSA8YSBocmVmPSJmYXEuaHRtbCNsb2NhbGl6YXRpb24iPkZBUTwvYT4gZm9yIGRldGFpbHMuDQoJQmFzZWQgb24gYSBjb25jZXB0IGJ5IElhaW4gU2hpZ2Vva2EuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBGaWVsZFNldCBGb3JtICZsdDstJmd0OyBEQU8gYXV0by1sb2FkaW5nIGJ1Zy4gVGhlIGZpeCB3YXMgcHJvdmlkZWQNCiAgICAgICAgYnkgUGF1bCBSdWxlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjAiPjIzPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBXZWJTcGhlcmUncyBidW5kbGVkIEpET00gMC43IGNvbXBhdGliaWxpdHkgaXNzdWUuIFRoaXMgaXNzdWUgd2FzDQogICAgICAgIGlkZW50aWZpZWQgYnkgT2xpdmVyIEJ1cm4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMCI+MjU8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgSmFrYXJ0YSBDb21tb25zIEpBUnMgdG8gbGF0ZXN0IHZlcnNpb25zIHRvIHN1cHBvcnQgSGliZXJuYXRlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTkiPjE5PC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBSZW1vdmVkIENvbW1vbnMgTG9nZ2luZyBkZXBlbmRlbmN5IGluIENsaWNrIEV4dHJhcyB0byBhdm9pZCBXZWJTcGhlcmUNCiAgICAgICAgY2xhc3MgbG9hZGluZyBpc3N1ZXMNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0yMCI+MjA8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIFVwZGF0ZWQgVmVsb2NpdHkgMS41IGRldiBidWlsZCB0byB1c2UgcmVjZW50IHNuYXBzaG90DQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMjEiPjIxPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBGaXhlZCBOUEUgYnVnIGluIEVycm9yUmVwb3J0LiBUaGlzIGZpeCB3YXMgcHJvdmlkZWQgYnkgU3RldmUgQ293eC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+VXBkYXRlZCBkb2N1bWVudGF0aW9uIGFuZCBleGFtcGxlcy48L2xpPg0KICAgIDwvdWw+DQogIDwvZGQ+DQogIDxwLz4NCiAgPGR0PlZlcnNpb24gMC4xMiAtIDFzdCBPY3RvYmVyIDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRmllbGRTZXQuaHRtbCI+RmllbGRTZXQ8L2E+DQogICAgICAgIGNvbnRyb2wuIFNlZSBKYXZhZG9jIGZvciBkZXRhaWxzIGFuZCBDbGljayBFeGFtcGxlcyBmb3IgYSBkZW1vbnN0cmF0aW9uDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy00Ij5DTEstNDwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkIEZpZWxkIDx0dD4ibmFtZSI8L3R0PiBhbmQgPHR0PiJsYWJlbCI8L3R0PiBjb25zdHJ1Y3RvcnMgYWRkZWQgdG8NCiAgICAgICAgbWFrZSBGb3JtICZsdDstJmd0OyBEQU8gYXV0by1sb2FkaW5nIGVhc2llciB0byB1c2UuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBDaGFuZ2VkIGNvbnRyb2xzIHRvIHJlbmRlciB2YWxpZCBYSFRNTCwgaW5zdGVhZCBvZiBIVE1MIDQuMDEsIGVuYWJsaW5nDQogICAgICAgIEZpcmVmb3ggYW5kIE1hYyBPUyBYICBicm93c2VycyB0byByZW5kZXIgQUpBWCByZXNwb25zZXMgY29udGFpbmluZyBDb250cm9sDQogICAgICAgIEhUTUwNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0zIj5DTEstMzwvYT5dLg0KICAgICAgICA8ZGl2IHN0eWxlPSJtYXJnaW4tdG9wOjAuNWVtOyI+DQogICAgICAgIEZvciBleGFtcGxlIHRoZSBUZXh0RmllbGQgSFRNTCAmbmJzcDsgPHR0PiZsdDtpbnB1dCB0eXBlPSd0ZXh0JyBkaXNhYmxlZCZndDs8L3R0Pg0KICAgICAgICAmbmJzcDsgbm93IHJlbmRlcnMgYXMgPGJyLz4gPHR0PiZsdDtpbnB1dCB0eXBlPSd0ZXh0JyBkaXNhYmxlZD0nZGlzYWJsZWQnLyZndDs8L3R0PiA8L2Rpdj4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIGJ1ZyB3aGVyZSBtdWx0aXBhcnQgZm9ybSBwYXJhbWV0ZXJzIG5vdCBhdmFpbGFibGUgZHVyaW5nDQogICAgICAgIDx0dD5QYWdlLm9uSW5pdCgpPC90dD4NCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xIj5DTEstMTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjExIC0gMTZ0aCBTZXB0ZW1iZXIgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgPGEgaHJlZj0iZXh0cmFzLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2V4dHJhcy9jb250cm9sL01lbnUuaHRtbCI+TWVudTwvYT4gY29tcG9uZW50Lg0KICAgICAgCVNlZSBKYXZhZG9jIGZvciBkZXRhaWxzIGFuZCBDbGljayBFeGFtcGxlcyBmb3IgYSBkZW1vbnN0cmF0aW9uDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy0xMiI+Q0xLLTEyPC9hPl0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIHJ1bnRpbWUgPGEgaHJlZj0idXNlci1ndWlkZS9odG1sL2NoMDRzMDIuaHRtbCNwYWdlLWF1dG8tbG9hZGluZyI+UGFnZSBBdXRvIExvYWRpbmc8L2E+DQogICAgICAgIHdoZW4gdGhlIGFwcGxpY2F0aW9uIGlzIGluDQogICAgICAgIDx0dD4iZGV2ZWxvcG1lbnQiPC90dD4sIDx0dD4iZGVidWciPC90dD4gb3IgPHR0PiJ0cmFjZSI8L3R0PiBtb2RlDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTgiPkNMSy0xODwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCBGb3JtICZsdDstJmd0OyBEQU8gYXV0by1sb2FkaW5nIGZlYXR1cmUuDQogICAgICAgIFNlZSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0Zvcm0uaHRtbCNjb3B5RnJvbShqYXZhLmxhbmcuT2JqZWN0KSI+Rm9ybTwvYT4NCiAgICAgICAgSmF2YWRvYyBmb3IgZGV0YWlscyBbPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMiI+Q0xLLTI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIEZpeGVkIGJsYW5rIHBhZ2UgZ3ppcCBjb21wcmVzc2lvbiBidWcuIFRoZSBDbGljayBlbWJlZGRlZCBnemlwIGNvbXByZXNzaW9uDQogICAgICAgIGZ1bmN0aW9uYWxpdHkgaGFzIGJlZW4gcmVwbGFjZWQgd2l0aCBhDQogICAgICAgIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvZmlsdGVyL0NvbXByZXNzaW9uRmlsdGVyLmh0bWwiPkNvbXByZXNzaW9uRmlsdGVyPC9hPg0KICAgICAgICBkZXJpdmVkIGZyb20gSmFya2F0YSBUb21jYXQNCiAgICAgICAgWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwczovL2lzc3Vlcy5hcGFjaGUub3JnL2ppcmEvYnJvd3NlL0NMSy01Ij5DTEstNTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQgPHR0PmVtYWlsKCk8L3R0PiBhbmQgPHR0PmxpbmsoKTwvdHQ+IGZvcm1hdHRlciBtZXRob2RzIGFuZA0KICAgICAgICA8dHQ+Z2V0RW1wdHlTdHJpbmcoKTwvdHQ+IG1ldGhvZCB0bw0KICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay91dGlsL0Zvcm1hdC5odG1sI2VtYWlsKGphdmEubGFuZy5TdHJpbmcpIj5Gb3JtYXQ8L2E+IGNsYXNzDQogICAgICAgIFs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cHM6Ly9pc3N1ZXMuYXBhY2hlLm9yZy9qaXJhL2Jyb3dzZS9DTEstMTUiPkNMSy0xNTwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgTW9kaWZpZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwiPkZvcm08L2E+DQogICAgICAgIGNvbnRyb2wgdG8gcmVuZGVyIGEgY2xhc3MgZXJyb3IgYXR0cmlidXRlICZsdDtsYWJlbCBjbGFzcz0iZXJyb3IiJmd0Ow0KICAgICAgICBpbiB0aGUgbGFiZWxzIG9mIGludmFsaWQgZmllbGRzLiBZb3UgY2FuIG5vdyBvdmVycmlkZSB0aGUgPHR0PmNvbnRyb2wuY3NzPC90dD4NCiAgICAgICAgc3R5bGUgPHR0PmxhYmVsLmVycm9yPC90dD4gdG8gbW9kaWZ5IHRoZSBkaXNwbGF5IG9mIGZpZWxkIGVycm9yIGxhYmVscy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIE1vZGlmaWVkIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI0Zvcm0oamF2YS5sYW5nLlN0cmluZykiPkZvcm08L2E+DQogICAgICAgIGNvbnN0cnVjdG9yIHRvIG9ubHkgcmVxdWlyZSBmb3JtIG5hbWUgcGFyYW1ldGVyLiBUaGUgY29udGV4dCBjYW4gYmUNCiAgICAgICAgc2V0IGxhdGVyLiBOb3RlIHRoaXMgd2lsbCByZXF1aXJlIG1vZGlmaWNhdGlvbnMgdG8gZXhpdGluZyBjb2RlLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5VcGRhdGVkIGRvY3VtZW50YXRpb24gYW5kIGV4YW1wbGVzLjwvbGk+DQogICAgPC91bD4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjEwIC0gMXN0IFNlcHRlbWJlciAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDxkaXYgc3R5bGU9Im1hcmdpbi1sZWZ0Oi0yZW07bWFyZ2luLWJvdHRvbTowLjVlbTsiPiBOZXcgZGV2ZWxvcGVyDQogICAgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9wYmFybmVzLyI+UGhpbCBCYXJuZXM8L2E+DQogICAgam9pbnMgdGhlIENsaWNrIHByb2plY3QuPC9kaXY+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUFkZGVkIDxhIGhyZWY9ImV4dHJhcy1hcGkvb3JnL2FwYWNoZS9jbGljay9leHRyYXMvcGFuZWwvcGFja2FnZS1zdW1tYXJ5Lmh0bWwiPlBhbmVsPC9hPg0KICAgICAgICBjb21wb25lbnRzIGJ5IFBoaWwgQmFybmVzLiBTZWUgSmF2YWRvYyBmb3IgZGV0YWlscyBhbmQgQ2xpY2sgRXhhbXBsZXMgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9UYWJsZS5odG1sIj5UYWJsZTwvYT4gY29udHJvbC4NCiAgICAgIAlTZWUgSmF2YWRvYyBmb3IgZGV0YWlscyBhbmQgQ2xpY2sgRXhhbXBsZXMgZm9yIGEgZGVtb25zdHJhdGlvbg0KICAgICAgCVs8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC90cmFja2VyL2luZGV4LnBocD9mdW5jPWRldGFpbCZhaWQ9MTI0MzI0MyZncm91cF9pZD04MjA5NSZhdGlkPTU2NTAyNyI+MTI0MzI0MzwvYT5dLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgIAlBZGRlZCA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ltYWdlU3VibWl0Lmh0bWwiPkltYWdlU3VibWl0PC9hPg0KICAgICAgICBjb250cm9sIGJ5IFBoaWwgQmFybmVzLiBTZWUgSmF2YWRvYyBmb3IgZGV0YWlscyBhbmQgQ2xpY2sgRXhhbXBsZXMgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgIExvY2FsaXphdGlvbi9JMThOIGNoYW5nZXMgaW5jbHVkZToNCiAgICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgICBBZGRlZCBDaGluZXNlIGxvY2FsaXphdGlvbiBwcm9wZXJ0aWVzICh6aF9DTikgcHJvdmlkZWQgYnkgWGkgUGluZyBXYW5nLiA8L2Rpdj4NCiAgICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgICBBZGRlZCBQYWdlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL3V0aWwvTWVzc2FnZXNNYXAuaHRtbCI+TWVzc2FnZXNNYXA8L2E+DQogICAgICAgIGFkYXB0b3IgdG8gVmVsb2NpdHkgQ29udGV4dC4NCiAgICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgCUFkZGVkIG5ldyA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9Db250ZXh0Lmh0bWwjZ2V0TG9jYWxlKCkiPmdldExvY2FsZSgpPC9hPg0KICAgICAgICBhbmQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI3NldExvY2FsZShqYXZhLnV0aWwuTG9jYWxlKSI+c2V0TG9jYWxlKCk8L2E+DQogICAgICAgIG1ldGhvZHMgdG8gQ29udGV4dCBjbGFzcyB0byBlbmFibGUgb3ZlcnJpZGluZyB0aGUgZGVmYXVsdCByZXF1ZXN0IExvY2FsZS4gPC9kaXY+DQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCU5ldyA8YSBocmVmPSJleHRyYXMtYXBpL292ZXJ2aWV3LXN1bW1hcnkuaHRtbCI+Q2xpY2sgRXh0cmFzPC9hPiBtb2R1bGUgYW5kIEpBUiBwcm92aWRlZCBmb3INCiAgICAgICAgY29udHJpYnV0aW9ucyBhbmQgbm9uLWNvcmUgZnJhbWV3b3JrIGNvbXBvbmVudHMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCU5ldyBSaWNvIGluc3BpcmVkIEFKQVggTGl2ZSBHcmlkIGV4YW1wbGUgcHJvdmlkZWQgYnkgUGhpbCBCYXJuZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgCUNsaWNrIEV4YW1wbGVzLCBDb25mbHVlbmNlIFdJS0kgYW5kIEpJUkEgYXBwbGljYXRpb25zIGFyZSBub3cgYXZhaWxhYmxlIG9ubGluZS4NCiAgICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgICBTcGVjaWFsIHRoYW5rcyB0byBQaGlsIEJhcm5zIGZvciBob3N0aW5nIHRoZXNlIGFwcGxpY2F0aW9ucy4gPC9kaXY+DQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuOSAtIDd0aCBBdWd1c3QgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgYXBwbGljYXRpb24gcmVsb2FkaW5nIGZlYXR1cmUgdG8gcmVsb2FkICJjbGljay54bWwiIHdpdGhvdXQNCiAgICAgIAlyZXN0YXJ0aW5nIHRoZSB3ZWIgYXBwbGljYXRpb24uDQogICAgICAJU2VlDQogICAgICAJPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ2xpY2tTZXJ2bGV0Lmh0bWwjYXBwLXJlbG9hZGluZyI+Q2xpY2tTZXJ2bGV0PC9hPg0KICAgICAgCUphdmFkb2MgZm9yIGRldGFpbHMgYW5kIHRoZSBDbGljayBFeGFtcGxlcyBmb3IgYSBkZW1vbnN0cmF0aW9uDQogICAgICAJWzxhIHRhcmdldD0nX2JsYW5rJyBocmVmPSJodHRwOi8vc291cmNlZm9yZ2UubmV0L3RyYWNrZXIvaW5kZXgucGhwP2Z1bmM9ZGV0YWlsJmFpZD0xMjUwOTc4Jmdyb3VwX2lkPTgyMDk1JmF0aWQ9NTY1MDI3Ij4xMjM3OTQyPC9hPl0uDQogICAgICAgIDxkaXYgc3R5bGU9Im1hcmdpbi10b3A6MC41ZW07Ij4NCiAgICAgICAgVGhpcyBjb25jZXB0IHdhcyBkZWZpbmVkIGJ5IDxhIHRhcmdldD0iYmxhbmsiIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdXNlcnMvaGFuc2JhZWNrZXJtLyI+SGFucyBCYWVja2VyLU1heWVyPC9hPi4gPC9kaXY+DQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuOCAtIDJuZCBBdWd1c3QgMjAwNTwvZHQ+DQogIDxkZD4NCiAgICA8dWwgc3R5bGU9InBhZGRpbmc6IDBlbTsgbWFyZ2luLWxlZnQ6MGVtOyI+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAJQWRkZWQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svc2VydmljZS9Mb2dTZXJ2aWNlLmh0bWwiPkxvZ1NlcnZpY2U8L2E+DQogICAgICAJd2hpY2ggbG9ncyB0byB0aGUgY29uc29sZSBieSBkZWZhdWx0Lg0KICAgICAgCVNlZSB0aGUgQ2xpY2sgYW5kICBWZWxvY2l0eSA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2NsaWNrLWxvZ2dpbmciPkxvZ2dpbmc8L2E+DQogICAgICAJdG9waWMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuNyAtIDI4dGggSnVseSAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZA0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWxlRmllbGQuaHRtbCI+RmlsZUZpZWxkPC9hPg0KICAgICAgICAgY29udHJvbCBmb3IgdXBsb2FkaW5nIGZpbGVzIGFuZCBtb2RpZmllZCBGb3JtIGNvbnRyb2wgdG8gc3VwcG9ydA0KICAgICAgICAgIm11bHRpcGFydC9mb3JtLWRhdGEiIHJlcXVlc3RzLiBTZWUgdGhlIENsaWNrIEV4YW1wbGVzDQogICAgICAgICBGaWxlIFVwbG9hZCBwYWdlIGZvciBhIGRlbW9uc3RyYXRpb24gWzxhIGhyZWY9Imh0dHA6Ly9zb3VyY2Vmb3JnZS5uZXQvdHJhY2tlci9pbmRleC5waHA/ZnVuYz1kZXRhaWwmYWlkPTEyMzc5NDImZ3JvdXBfaWQ9ODIwOTUmYXRpZD01NjUwMjciPjEyMzc5NDI8L2E+XS4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZXMiPg0KICAgICAgICBBZGRlZCBwYWdlcyA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2FwcGxpY2F0aW9uLWF1dG9tYXBwaW5nIj5BdXRvIE1hcHBpbmc8L2E+DQogICAgICAgIGNvbmZpZ3VyYXRpb24gb3B0aW9uLiBUaGlzIGZlYXR1cmUgY2FuIGF1dG9tYXRpY2FsbHkgbWFwIEhUTUwgcGFnZQ0KICAgICAgICB0ZW1wbGF0ZXMgdG8gUGFnZSBjbGFzc2VzIHNvIHlvdSBkb24ndCBoYXZlIHRvIGRlY2xhcmUgdGhlbSBtYW51YWxseSBpbg0KICAgICAgICB0aGUgY2xpY2sueG1sIGNvbmZpZ3VyYXRpb24gZmlsZS4NCiAgICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgICBUaGlzIGNvbmNlcHQgd2FzIGRlZmluZWQgYnkgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9hbW9ob21iZS8iPkFobWVkIE1vaG9tYmU8L2E+LiA8L2Rpdj4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZXMiPg0KICAgICAgICBBZGRlZA0KICAgICAgICA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMwNS5odG1sI3BhZ2UtZm9yd2FyZGluZyI+UGFnZSBGb3J3YXJkaW5nPC9hPg0KICAgICAgICBlbmFibGluZyB5b3UgdG8gY29uZmlndXJlIHRoZSBQYWdlIHRvIGZvcndhcmQgdGhlIHJlcXVlc3QgdG8uDQogICAgICAgIFRoaXMgcHJvdmlkZXMgc2ltaWxhciBmdW5jdGlvbmFsaXR5IGFzIFRhcGVzdHJ5J3MgPHR0PmN5Y2xlLmdldFBhZ2UoKTwvdHQ+DQogICAgICAgIGludGVycGFnZSBjYWxsaW5nIHRlY2huaXF1ZS4gU2VlIHRoZSBFeGFtcGxlcyBQYWdlDQogICAgICAgIEZsb3cgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZXMiPg0KICAgICAgICBBZGRlZA0KICAgICAgICBDbGlja1NlcnZsZXQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ2xpY2tTZXJ2bGV0Lmh0bWwjbmV3UGFnZUluc3RhbmNlKGphdmEubGFuZy5DbGFzcywgamF2YXguc2VydmxldC5odHRwLkh0dHBTZXJ2bGV0UmVxdWVzdCkiPm5ld1BhZ2VJbnN0YW5jZSgpPC9hPg0KICAgICAgICBtZXRob2QgdG8gc3VwcG9ydCBJb0MgYXBwbGljYXRpb25zLiBTZWUgdGhlDQogICAgICAgIDxhIGhyZWY9ImZhcS5odG1sI3NwcmluZy1pbnRlZ3JhdGlvbiI+U3ByaW5nIEludGVncmF0aW9uPC9hPiBGQVEgdG9waWMgZm9yIG1vcmUgZGV0YWlscy4NCiAgICAgICAgPGRpdiBzdHlsZT0ibWFyZ2luLXRvcDowLjVlbTsiPg0KICAgICAgICBUaGlzIGNvbmNlcHQgd2FzIGRlZmluZWQgYnkgPGEgdGFyZ2V0PSJibGFuayIgaHJlZj0iaHR0cDovL3NvdXJjZWZvcmdlLm5ldC91c2Vycy9wYmFybmVzLyI+UGhpbCBCYXJuZXM8L2E+LiA8L2Rpdj4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZXMiPg0KICAgICAgICBGb3JtIHJlbmRlcmluZyBpbXByb3ZlZCB0byBpbmNsdWRlIENTUyBjbGFzc2VzICJmaWVsZHMiLCAiZXJyb3JzIiBhbmQgImJ1dHRvbnMiDQogICAgICAgIGluIHRoZSByZXNwZWN0aXZlIHRhYmxlICZsdDt0ciZndDsgYW5kICZsdDt0ZCZndDsgZWxlbWVudHMuIFRoaXMgZW5hYmxlcyBncmVhdGVyDQogICAgICAgIGNvbnRyb2wgb2YgRm9ybSBkaXNwbGF5IHVzaW5nIENTUyBzdHlsZXMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBBZGRlZCAidHJhY2UiIGFwcGxpY2F0aW9uIG1vZGUgdG8gcHJvdmlkZSBtb3JlIGRldGFpbGVkIGxvZ2dpbmcuDQogICAgICAgIFNlZSB0aGUgQ29uZmlndXJhdGlvbiA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwNHMwMi5odG1sI2FwcGxpY2F0aW9uLW1vZGUiPk1vZGU8L2E+IHRvcGljLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj4NCiAgICAgICAgQWRkZWQNCiAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svdXRpbC9Gb3JtYXQuaHRtbCNsaW1pdExlbmd0aChqYXZhLmxhbmcuU3RyaW5nLCBpbnQpIj5saW1pdExlbmd0aCgpPC9hPg0KICAgICAgICBtZXRob2RzIHRvIHRoZSBGb3JtYXQgY2xhc3MuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICBJbXByb3ZlZCBTdWJtaXQgY29udHJvbHMgcHJvY2Vzc2luZyBvZiBIVE1MIGNoYXJhY3RlcnMuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuNiAtIDJuZCBKdWx5IDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIEFKQVggRHluYW1pYyBIVE1MIGFuZCBYTUwgcmVxdWVzdCBleGFtcGxlIHVzaW5nDQogICAgICAgICB0aGUgdXNpbmcgUmljbyBBamF4IGxpYnJhcnkuIFNlZSB0aGUgQ2xpY2sgRXhhbXBsZXMgQUpBWCBwYWdlIGZvciBhIGRlbW9uc3RyYXRpb24uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPg0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9PcHRpb24uaHRtbCI+T3B0aW9uPC9hPiBhbmQNCiAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvT3B0aW9uR3JvdXAuaHRtbCI+T3B0aW9uR3JvdXA8L2E+DQogICAgICAgICAgcmVmYWN0b3JlZCBpbnRvIHN0YW5kYWxvbmUgY2xhc3Nlcy4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+DQogICAgICAgICBBZGRlZCBQYWdlDQogICAgICAgICA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9QYWdlLmh0bWwjc2V0SGVhZGVyKGphdmEubGFuZy5TdHJpbmcsIGphdmEubGFuZy5PYmplY3QpIj5zZXRIZWFkZXIoKTwvYT4NCiAgICAgICAgIG1ldGhvZC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+Rml4ZWQgTlBFIHdoZW4gRmllbGRzLCB3aXRoIG5vIHBhcmVudCBGb3JtLCBhcmUgcHJvY2Vzc2VkDQogICAgICAgICBhbmQgcmVuZGVyZWQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIEZBUSwgYW5kIHVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuNSAtIDFzdCBKdW5lIDIwMDU8L2R0Pg0KICA8ZGQ+DQogICAgPHVsIHN0eWxlPSJwYWRkaW5nOiAwZW07IG1hcmdpbi1sZWZ0OjBlbTsiPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkZvcm0gY29udHJvbCBlbmNvZGVzIHRoZSBmb3JtIDx0dD4iYWN0aW9uIjwvdHQ+IFVSTCBhdHRyaWJ1dGUgdXNpbmcNCiAgICAgICAgIDxhIGNsYXNzPSJleHRlcm5hbCIgdGFyZ2V0PSJfYmxhbmsiIGhyZWY9Imh0dHA6Ly9qYXZhLnN1bi5jb20vcHJvZHVjdHMvc2VydmxldC8yLjMvamF2YWRvYy9qYXZheC9zZXJ2bGV0L2h0dHAvSHR0cFNlcnZsZXRSZXNwb25zZS5odG1sI2VuY29kZVVSTChqYXZhLmxhbmcuU3RyaW5nKSI+ZW5jb2RlVVJMKFN0cmluZyk8L2E+DQogICAgICAgICB0byBlbnN1cmUgc2Vzc2lvbiBJRCBpcyBzZXQuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIG9wdGlvbmFsIEZvcm0gdmFsaWRhdGlvbi4gQQ0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjdmFsaWRhdGUiPnZhbGlkYXRlPC9hPg0KICAgICAgICAgcHJvcGVydHkgaGFzIGJlZW4gYWRkZWQgdG8gRm9ybSBhbmQgYSA8YSBocmVmPSJjbGljay1hcGkvb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0ZpZWxkLmh0bWwjdmFsaWRhdGUoKSI+dmFsaWRhdGUoKTwvYT4NCiAgICAgICAgIG1ldGhvZCB0byBGaWVsZC4gRmllbGQgc3ViY2xhc3NlcyBoYXZlIGJlZW4gbW9kaWZpZWQgdG8gc3VwcG9ydCBvcHRpb25hbA0KICAgICAgICAgdmFsaWRhdGlvbi4gIFNlZSB0aGUgQ2xpY2sgRXhhbXBsZXMgRm9ybSBQcm9wZXJ0aWVzIHBhZ2UgZm9yIGEgZGVtb25zdHJhdGlvbi4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+QWRkZWQgU2Vzc2lvbiBPYmplY3QgdXRpbGl0eSBtZXRob2RzIHRvIENvbnRleHQsIHNlZQ0KICAgICAgICAgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udGV4dC5odG1sI2dldFNlc3Npb25PYmplY3QoamF2YS5sYW5nLkNsYXNzKSI+Z2V0U2Vzc2lvbk9iamVjdDwvYT4uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIGVycm9yIG1lc3NhZ2UgYmxvY2sgaG9yaXpvbnRhbCBhbGlnbm1lbnQgcHJvcGVydHkNCiAgICAgICAgIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRm9ybS5odG1sI2Vycm9yc0FsaWduIj5lcnJvcnNBbGlnbjwvYT4NCiAgICAgICAgIHRvIEZvcm0uDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuNCAtIE1heSAyMDA1PC9kdD4NCiAgPGRkPg0KICAgIDx1bCBzdHlsZT0icGFkZGluZzogMGVtOyBtYXJnaW4tbGVmdDowZW07Ij4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5JbXBsZW1lbnRlZCA8YSBocmVmPSJ1c2VyLWd1aWRlL2h0bWwvY2gwMnMwNi5odG1sI3BhZ2UtdGVtcGxhdGluZyI+UGFnZSBUZW1wbGF0aW5nPC9hPg0KICAgICAgICAgY2FwYWJpbGl0eS4gRW5hYmxpbmcgeW91IHRvIGNyZWF0ZSBhIHN0YW5kYXJkaXplZCBsb29rIGFuZCBmZWVsIGZvciB5b3VyIHdlYg0KICAgICAgICAgYXBwbGljYXRpb24gYW5kIGdyZWF0bHkgcmVkdWNpbmcgdGhlIGFtb3VudCBvZiBIVE1MIHlvdSBuZWVkIHRvIG1haW50YWluLg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5JbXByb3ZlZCBFcnJvciBoYW5kbGluZy4gQXBwbGljYXRpb24gZXhjZXB0aW9ucyByZW5kZXINCiAgICAgICAgIGVycm9yIHNvdXJjZSBsaW5lIHdoZW4gSmF2YSBzb3VyY2UgYXZhaWxhYmxlLiBGb3IgZXhhbXBsZSBhDQogICAgICAgICA8YSBocmVmPSJlcnJvci1ucGUuaHRtbCI+TnVsbFBvaW50ZXJFeGNlcHRpb248L2E+Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5JbnRlZ3JhdGVkIHRoZSBESFRNTCBDYWxlbmRhciB3aWRnZXQgYnkgPGEgaHJlZj0iaHR0cDovL3d3dy5keW5hcmNoLmNvbS8iPkR5bmEuY29tPC9hPg0KICAgICAgICAgaW50byA8YSBocmVmPSJleHRyYXMtYXBpL29yZy9hcGFjaGUvY2xpY2svZXh0cmFzL2NvbnRyb2wvRGF0ZUZpZWxkLmh0bWwiPkRhdGVGaWVsZDwvYT4gY29udHJvbC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+QWRkZWQgRm9ybSBhbmQgRmllbGQgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9GaWVsZC5odG1sI3JlYWRvbmx5Ij5yZWFkb25seTwvYT4NCiAgICAgICAgIHByb3BlcnR5LiBNb2RpZmllZCBGaWVsZCBzdWJjbGFzc2VzIHRvIHJlbmRlciB0aGVpciBIVE1MIHJlYWRvbmx5IGF0dHJpYnV0ZS4gSWYgdGhlIEZvcm0gaXMgc2V0IHRvDQogICAgICAgICByZWFkb25seSBhbGwgaXRzIGZpZWxkcyB3aWxsIGFsc28gYmUgcmVhZG9ubHkuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIENvbnRyb2wgPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svQ29udHJvbC5odG1sI2dldElkKCkiPmdldElkKCk8L2E+DQogICAgICAgICBtZXRob2QuIE1vZGlmaWVkIGNvbnRyb2wgY2xhc3NlcyB0byByZW5kZXIgdGhlaXIgSFRNTCBpZCBhdHRyaWJ1dGUuDQogICAgICA8L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPkFkZGVkIEZvcm0gPGEgaHJlZj0iY2xpY2stYXBpL29yZy9hcGFjaGUvY2xpY2svY29udHJvbC9Gb3JtLmh0bWwjY29sdW1ucyI+Y29sdW1uczwvYT4NCiAgICAgICAgIHByb3BlcnR5IHRvIHJlbmRlciBmb3JtcyBpbiBtdWx0aSBjb2x1bW4gdGFibGUgbGF5b3V0Lg0KICAgICAgPC9saT4NCiAgICAgIDxsaSBjbGFzcz0iY2hhbmdlIj5BZGRlZCBwYWdlIDxhIGhyZWY9ImNsaWNrLWFwaS9vcmcvYXBhY2hlL2NsaWNrL1BhZ2UuaHRtbCNwYXRoIj5wYXRoPC9hPg0KICAgICAgICAgcHJvcGVydHkgdG8gVmVsb2NpdHkgY29udGV4dC4NCiAgICAgIDwvbGk+DQogICAgICA8bGkgY2xhc3M9ImNoYW5nZSI+Rml4ZWQgU291cmNlVmlld2VyIG1pc3NpbmcgcmVzb3VyY2UgYnVnIHdoaWNoIG9jY3VycmVkIG9uIE9yaW9uIHNlcnZlci48L2xpPg0KICAgICAgPGxpIGNsYXNzPSJjaGFuZ2UiPlVwZGF0ZWQgZG9jdW1lbnRhdGlvbiBhbmQgZXhhbXBsZXMuPC9saT4NCiAgICA8L3VsPg0KICA8L2RkPg0KICA8cC8+DQogIDxkdD5WZXJzaW9uIDAuMyAtIE1hcmNoIDIwMDU8L2R0Pg0KICA8ZGQ+UHJlbGltaW5hcnkgcmVsZWFzZSBmb3IgcHVibGljIHJldmlldy4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjIgLSAyMDA0PC9kdD4NCiAgPGRkPg0KICAgIE1ham9yIHJld3JpdGUsIHJlcGxhY2luZyBjb21tYW5kIHBhdHRlcm4gd2l0aCBQYWdlIG9yaWVudGVkIGRlc2lnbi4gQ2xpY2sNCiAgICBhcHBsaWNhdGlvbiBkZXNjcmlwdG9yIHJhdGlvbmFsaXplZCBhbmQgc2ltcGxpZmllZC4NCiAgPC9kZD4NCiAgPHAvPg0KICA8ZHQ+VmVyc2lvbiAwLjEgLSAyMDAzPC9kdD4NCiAgPGRkPkluaXRpYWwgQ2xpY2sgdmVyc2lvbi4gVXNlcyBDb21tYW5kIHBhdHRlcm4gYW5kIFZlbG9jaXR5IHRlbXBsYXRpbmcgZW5naW5lLg0KICAgIDxwLz4NCiAgICBDbGljayB0ZWFtIGJsb2dnaW5nIGFwcGxpY2F0aW9uIGRlcGxveWVkIG9uIFRvbWNhdCA0LjAgYW5kIE9yYWNsZSA5aSBhcHBsaWNhdGlvbiBzZXJ2ZXJzLg0KICA8L2RkPg0KICA8cC8+DQo8L2RsPg0KDQo8IS0tIEZPT1RFUiAtLT4NCjxkaXYgaWQ9ImZvb3RlciI+DQogICAgPGhyLz4NCiAgICA8cD4NCiAgICA8YSB0YXJnZXQ9J19ibGFuaycgaHJlZj0naHR0cDovL3d3dy5hcGFjaGUub3JnJyB0aXRsZT0nQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24nPg0KICAgICAgICA8aW1nIGlkPSJhc2YtbG9nbyIgc3JjPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvaW1hZ2VzL2FzZi1sb2dvLmdpZiIgYWx0PSJBcGFjaGUgU29mdHdhcmUgRm91bmRhdGlvbiIvPg0KICAgIDwvYT4NCiAgICBDb3B5cmlnaHQgJmNvcHk7IDIwMDEtMjAxMyBBcGFjaGUgU29mdHdhcmUgRm91bmRhdGlvbi4gQXBhY2hlIENsaWNrLA0KICAgIENsaWNrLCBBcGFjaGUsIHRoZSBBcGFjaGUgZmVhdGhlciBsb2dvLCBhbmQgdGhlIEFwYWNoZSBDbGljayBwcm9qZWN0IGxvZ28gYXJlDQogICAgdHJhZGVtYXJrcyBvZiBUaGUgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24uDQogICAgPGEgaHJlZj0iaHR0cDovL2NheWVubmUuYXBhY2hlLm9yZy9wcml2YWN5LXBvbGljeS5odG1sIj5Qcml2YWN5IHBvbGljeS48L2E+DQogICAgPC9wPg0KPC9kaXY+DQoNCjwvYm9keT4NCjwvaHRtbD4NCg0K