PD9waHAgIAkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCXJlcXVpcmVfb25jZSgkX1NFUlZFUlsnRE9DVU1FTlRfUk9PVCddIC4gIi9lY2xpcHNlLm9yZy1jb21tb24vc3lzdGVtL2FwcC5jbGFzcy5waHAiKTsJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbmF2LmNsYXNzLnBocCIpOyAJcmVxdWlyZV9vbmNlKCRfU0VSVkVSWydET0NVTUVOVF9ST09UJ10gLiAiL2VjbGlwc2Uub3JnLWNvbW1vbi9zeXN0ZW0vbWVudS5jbGFzcy5waHAiKTsgCSRBcHAgCT0gbmV3IEFwcCgpOwkkTmF2CT0gbmV3IE5hdigpOwkkTWVudSAJPSBuZXcgTWVudSgpOwkJaW5jbHVkZSgkQXBwLT5nZXRQcm9qZWN0Q29tbW9uKCkpOyAgICAjIEFsbCBvbiB0aGUgc2FtZSBsaW5lIHRvIHVuY2x1dHRlciB0aGUgdXNlcidzIGRlc2t0b3AnCgokcGFnZVRpdGxlIAkJPSAiIjsKJHBhZ2VLZXl3b3Jkcwk9ICIiOwokcGFnZUF1dGhvcgkJPSAiIjsKCm9iX3N0YXJ0KCk7Cj8+CgogICAgPGRpdiBpZD0ibWFpbmNvbnRlbnQiPgoJPGRpdiBpZD0ibWlkY29sdW1uIj4KCjxoMT5UaGUgRUNNIFJpY2ggQ2xpZW50IFBsYXRmb3JtIChBcG9nZWUpIFByb2plY3Q8L2gxPgo8P3BocAppbmNsdWRlX29uY2UoJF9TRVJWRVJbJ0RPQ1VNRU5UX1JPT1QnXSAuICIvcHJvamVjdHMvZnJhZ21lbnRzL3Byb3Bvc2FsLXBhZ2UtaGVhZGVyLnBocCIpOwpnZW5lcmF0ZV9oZWFkZXIoIkVDTSBSaWNoIENsaWVudCBQbGF0Zm9ybSAoQXBvZ2VlKSIpOwo/PgoKPGI+QW4gRWNsaXBzZSBUZWNobm9sb2d5IFByb2plY3QgUHJvcG9zYWw8YnIgLz4KTWFyY2ggMjAwNjwvYj4KCgoKPGgyPkludHJvZHVjdGlvbjwvaDI+CjxwPlRoZSBBcG9nZWUgUHJvamVjdCBpcyBhIHByb3Bvc2VkIG9wZW4gc291cmNlIHByb2plY3QgdW5kZXIgdGhlIDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvdGVjaG5vbG9neS8iPkVjbGlwc2UgVGVjaG5vbG9neSBQcm9qZWN0PC9hPi48L3A+Cgo8cD5UaGlzIHByb3Bvc2FsIGlzIGluIHRoZSBQcm9qZWN0IFByb3Bvc2FsIFBoYXNlIChhcyBkZWZpbmVkIGluIHRoZSA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL3Byb2plY3RzL2Rldl9wcm9jZXNzLyI+RWNsaXBzZSBEZXZlbG9wbWVudCBQcm9jZXNzPC9hPiBkb2N1bWVudCkgYW5kIGlzIHdyaXR0ZW4gdG8gZGVjbGFyZSBpdHMgaW50ZW50IGFuZCBzY29wZS4gVGhpcyBwcm9wb3NhbCBpcyB3cml0dGVuIHRvIHNvbGljaXQgYWRkaXRpb25hbCBwYXJ0aWNpcGF0aW9uIGFuZCBpbnB1dCBmcm9tIHRoZSBFY2xpcHNlIGNvbW11bml0eS4gWW91IGFyZSBpbnZpdGVkIHRvIGNvbW1lbnQgb24gYW5kL29yIGpvaW4gdGhlIHByb2plY3QuIFBsZWFzZSBzZW5kIGFsbCBmZWVkYmFjayB0byB0aGUgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9uZXdzcG9ydGFsL3RocmVhZC5waHA/Z3JvdXA9ZWNsaXBzZS50ZWNobm9sb2d5LmFwb2dlZSI+ZWNsaXBzZS50ZWNobm9sb2d5LmFwb2dlZSBuZXdzZ3JvdXA8L2E+LjwvcD4KCiAgPGgyPkJhY2tncm91bmQ8L2gyPgoKICA8cD5UaGlzIHByb2plY3QgY29tZXMgZnJvbSBvdXIgdGhvdWdodCBhYm91dCBuZXh0IHN0ZXBzIGluIHRoZSA8YSBocmVmPQogICJodHRwOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL0VudGVycHJpc2VfY29udGVudF9tYW5hZ2VtZW50Ij5FbnRlcnByaXNlIENvbnRlbnQgTWFuYWdlbWVudDwvYT4gKEVDTSkgbWFya2V0LiBNb3JlIGFuZCBtb3JlIGN1c3RvbWVycyBuZWVkIHNwZWNpZmljIGFwcGxpY2F0aW9uIHJlbGF0ZWQgdG8gRUNNIHRvIHByb3Blcmx5IGhhbmRsZSB0aGVpciBkYXRhIGFuZCBpbnRlZ3JhdGUgaW4gYSBzZWFtbGVzcyB3YXkgYWxsIHRoZWlyIGRpZ2l0YWwgYXNzZXRzIGFuZCBpbnZvbHZlZCBwcm9jZXNzZXMuIFRoZXNlIGFwcGxpY2F0aW9ucwogIHNoYXJlIGEgbG90IG9mIGZlYXR1cmVzIGFuZCBuZWVkIG1hbnkgY29tbW9uIHNlcnZpY2VzLiBFQ00gYXBwbGljYXRpb25zIGRldmVsb3BlcnMgZGVmaW5pdGVseSBuZWVkCiAgYSBmcmFtZXdvcmsgdGhhdCB3b3VsZCBlYXNlIHRoZSBjcmVhdGlvbiBvZiB0aGlzIGtpbmQgb2YgZGVza3RvcAogIGFwcGxpY2F0aW9ucywgd2hlbiB0aGUgYnJvd3NlciBpcyBub3QgZW5vdWdoLi4uPC9wPgoKICA8cD48YSBocmVmPQogICJodHRwOi8vd2lraS5lY2xpcHNlLm9yZy9pbmRleC5waHAvUmljaF9DbGllbnRfUGxhdGZvcm0iPkVjbGlwc2UKICBSQ1A8L2E+IGlzIGV4cGVjdGVkIHRvIHBsYXkgYSBtYWpvciByb2xlIGZvciBuZXh0IGdlbmVyYXRpb24KICBkZXNrdG9wIGFwcGxpY2F0aW9ucy4gSW4gdGhlIEVDTSBidXNpbmVzcywgd2ViIGludGVyZmFjZXMgYXJlIGdyZWF0LCBidXQKICBzb21lIGN1c3RvbWVycyAvIGFwcGxpY2F0aW9ucyBuZWVkIG1vcmUgKGhpZ2hseSByZXNwb25zaXZlIGludGVyZmFjZSwKICByaWNoIFVJLCBkZXNrdG9wIGludGVncmF0aW9uLCBvZmZsaW5lIG1vZGUgc3VwcG9ydCwgZXRjLikuPC9wPgoKICA8cD5BdCA8YSBocmVmPSJodHRwOi8vd3d3Lm51eGVvLmNvbS9lbiI+TnV4ZW88L2E+LCB3ZSBhbHJlYWR5IGhhdmUgZGVsaXZlcmVkIHNvbWUgcHJvamVjdHMgaW4gdGhpcyBhcmVhIGFuZCBoYXZlIGJlZ3VuIHRvCiAgY3JlYXRlIHN1Y2ggYSBmcmFtZXdvcmsgZm9yIEVDTSBhcHBsaWNhdGlvbnMsIGNhbGxlZCBBcG9nZWUuIEl0J3MgdGltZSB0byB0YWtlIGl0IHRvIHRoZSBuZXh0IGxldmVsLjwvcD4KCiAgPHA+VGhpcyBwcm9qZWN0IGFpbXMgYXQgYnVpbGRpbmcgYSBmcmFtZXdvcmsgdG8gY3JlYXRlIEVDTS1vcmllbnRlZAogIGRlc2t0b3AgYXBwbGljYXRpb25zLCBpbmRlcGVuZGVudCBmcm9tIHZlbmRvciBvciB0ZWNobm9sb2dpZXMuIFRoaXMKICBmcmFtZXdvcmsgY291bGQgYmUgdXNlZCB0byBjcmVhdGUgYXBwbGljYXRpb25zIHRoYXQgd2lsbCBiZSBpbnRlZ3JhdGVkCiAgd2l0aCA8YSBocmVmPSJodHRwOi8vd3d3LmRvY3VtZW50dW0uY29tLyI+RG9jdW1lbnR1bTwvYT4gLCA8YSBocmVmPQogICJodHRwOi8vaW50ZXJ3b3Zlbi5jb20vIj5JbnRlcndvdmVuPC9hPiAsIDxhIGhyZWY9CiAgImh0dHA6Ly93d3cuY3BzLXByb2plY3Qub3JnLyI+TnV4ZW8gQ1BTPC9hPiBvciBhbnkgRUNNCiAgcGxhdGZvcm0uPC9wPgoKICA8aDI+U2NvcGU8L2gyPgoKICA8cD5UaGlzIHByb2plY3QncyBnb2FscyBhcmUgdG8gOjwvcD4KCiAgPHVsPgogICAgPGxpPkRlZmluZSBnZW5lcmljIGNvbmNlcHRzIGFuZCBtb2RlbHMgcmVxdWlyZWQgdG8gY3JlYXRlIEVDTSBkZXNrdG9wCiAgICBhcHBsaWNhdGlvbnMgKGRvY3VtZW50cywgY29udGVudCB0eXBlcywgc3RvcmFnZSwgY29tbXVuaWNhdGlvbiwKICAgIHN0YW5kYXJkcywgd29ya2Zsb3csIHNlYXJjaCwgc3luY2hyb25pc2F0aW9uLCBvbmxpbmUvb2ZmbGluZSwKICAgIGV0Yy4pLjwvbGk+CgogICAgPGxpPkJ1aWxkIHRoZSBjb3JlIGluZnJhc3RydWN0dXJlIG5lZWRlZCBieSBkZXNrdG9wIEVDTSBhcHBsaWNhdGlvbnMsCiAgICBpbXBsZW1lbnRpbmcgdGhlIGNvbmNlcHRzIGFuZCBtb2RlbHMgZGVmaW5lZCBhYm92ZS48L2xpPgoKICAgIDxsaT5CdWlsZCBhIHNldCBvZiBoaWdobHktY3VzdG9taXphYmxlIGFwcGxpY2F0aW9uLWxldmVsIGNvbXBvbmVudHMgdGhhdAogICAgd291bGQgZWFzZSB0aGUgY3JlYXRpb24gb2YgRUNNIGRlc2t0b3AgYXBwbGljYXRpb25zIChtYWlsIGNsaWVudCwgSU0sCiAgICBmb3JtcywgY2FsZW5kYXIgY2xpZW50LCBkb2N1bWVudCBlZGl0b3IsIGV0Yy4pLjwvbGk+CiAgPC91bD4KCiAgPGgyPkRlc2NyaXB0aW9uPC9oMj4KCiAgPHA+VGhpcyBwcm9qZWN0IGlzIGRpdmlkZWQgaW50byAyIGFyZWE6Jm5ic3A7PC9wPgoKICA8dWw+CiAgICA8bGk+PHN0cm9uZz5Db3JlIFBsYXRmb3JtPC9zdHJvbmc+OiBvZmZlcnMgdGhlIGxvdyBsZXZlbCBkb2N1bWVudAogICAgbWFuYWdlbWVudCBpbmZyYXN0cnVjdHVyZTwvbGk+CgogICAgPGxpPjxzdHJvbmc+QXBwbGljYXRpb24gUGxhdGZvcm08L3N0cm9uZz46IGEgc2V0IG9mIGhpZ2hseSBleHRlbnNpYmxlCiAgICBhcHBsaWNhdGl2ZSBjb21wb25lbnRzPC9saT4KICA8L3VsPgoKICA8aDM+Q29yZSBQbGF0Zm9ybTwvaDM+CgogIDx1bD4KICAgIDxsaT5BIDxzdHJvbmc+Z2VuZXJpYyByZXNvdXJjZSBtb2RlbCAvIGNvbnRlbnQgcmVwb3NpdG9yeTwvc3Ryb25nPiB0aGF0IGNhbiBiZSBpbnRlZ3JhdGVkIHdpdGggRWNsaXBzZSdzIHJlc291cmNlIG1vZGVsLiA8YSBocmVmPSJodHRwOi8vd3d3LmpjcC5vcmcvZW4vanNyL2RldGFpbD9pZD0xNzAiPkpTUi0xNzA8L2E+ICg8YSBocmVmPSJodHRwOi8vd3d3LmpjcC5vcmcvZW4vanNyL2RldGFpbD9pZD0xNzAiPkphdmEgQ29udGVudCBSZXBvc2l0b3J5PC9hPikgaXMgY29uc2lkZXJlZCBhcyB0aGUgbmF0aXZlIGxvY2FsIHJlc291cmNlIG1vZGVsIGZvciBBcG9n6WUgKEpTUi0xNzAgYmVnaW5zIHRvIGJlIHdpZGVseSBhZG9wdGVkIGluIHRoZSBKYXZhIGNvbW11bml0eSkuIEFkYXB0ZXJzIGJldHdlZW4gSlNSLTE3MCBhbmQgRWNsaXBzZSByZXNvdXJjZSBtb2RlbCB3aWxsIGhhdmUgdG8gYmUgd3JpdHRlbi4gVGhlIG9wZW4gc291cmNlIGltcGxlbWVudGF0aW9uIG9mIHRoZSBKQ1IgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnLyI+QXBhY2hlPC9hPiBpcyA8YSBocmVmPSJodHRwOi8vamFja3JhYmJpdC5hcGFjaGUub3JnLyI+SmFja1JhYmJpdDwvYT4gYW5kIHNlZW1zIHRvIGJlIGEgZ29vZCBjYW5kaWRhdGUgZm9yIEFwb2fpZS4gRm9yIEphY2tSYWJiaXQncyBiYWNrZW5kIGFuZCBub24gY29udGVudC1yZWxhdGVkIGRhdGEgc3RvcmFnZSwgd2UgcGxhbiB0byBzdHVkeSA8YSBocmVmPSJodHRwOi8vd3d3LmRiNG9iamVjdHMub3JnLyI+ZGI0bzwvYT4gIChpdCBjb3VsZCBhbHNvIGJlIHVzZWQgYXMgUGVyc2lzdGVuY2VNYW5hZ2VyIGZvciBKYWNrUmFiYml0KS4gVmVuZG9ycyBzaG91bGQgYmUgYWxsb3dlZCB0byB3cml0ZSB0aGVpciBvd24gQXBvZ+llIGNvbm5lY3RvciwgYWxsb3dpbmcgdGhlbSB0byBjb25uZWN0IEFwb2fpZSB0byBFQ00gcGxhdGZvcm1zIHVzaW5nIHByb3ByaWV0YXJ5IGludGVyZmFjZXMuPGJyLz4KICAgIEFzIHRoZSBKQ1IgZG9lcyBub3QgZGVmaW5lIGEgZGF0YSBtb2RlbCwgQXBvZ+llIHdpbGwgc3RpbGwgbmVlZCB0byBwcm92aWRlIGEgY29udmVuaWVudCB3YXkgdG8gaGFuZGxlIGNvbnRlbnQgLyBkYXRhIG1vZGVsICh0aGlzIGlzIG1vcmUgZGV0YWlsZWQgaW4gdGhlIGNvbnRlbnQgcmVwb3NpdG9yeSBhbmQgc3RvcmFnZSBzcGVjaWZpY2F0aW9uIG9mIHRoZSBhcG9n6WUgcHJvamVjdCkuCiAgICA8L2xpPgoKICAgIDxsaT5BIDxzdHJvbmc+Zm9ybSBzZXJ2aWNlczwvc3Ryb25nPiAoYmFzZWQgb24gPGEgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvTWFya1VwL0Zvcm1zLyI+WEZvcm1zPC9hPikgdG8gZGVmaW5lIGNvbnRlbnQKICAgIGNyZWF0aW9uL2VkaXRpb24gZm9ybXMsIHVzZXIgaW50ZXJmYWNlIGZvcm1zIChsaWtlIHdvcmtmbG93IGFjdGlvbiBmb3JtcyksIGV0Yy4gdGhhdCB3b3VsZCBiZSBkaXJlY3RseSBkZWxpdmVyZWQgYnkgdGhlIEVDTSBwbGF0Zm9ybSB1c2luZyBYRm9ybXMgZm9ybXMsIGFjY29yZGluZyB0byB0aGUgY29udGVudCBtb2RlbCB1c2VkLgogICAgPGJyLz5UaGlzIHNlcnZpY2UgY2FuIGdlbmVyYXRlIEVjbGlwc2UgRm9ybXMgLyBTV1QgZnJvbSB0aGUgWEZvcm1zIGRlc2NyaXB0aW9uIHVzaW5nIHRoZSBFY2xpcHNlIFhGb3JtcyBlbmdpbmUuPC9saT4KCiAgICA8bGk+QSA8c3Ryb25nPmdlbmVyaWMgbW9kZWwgdG8gZGVmaW5lIGFjdGlvbnMgLyB2aWV3czwvc3Ryb25nPiBhdmFpbGFibGUgb24gYSBkb2N1bWVudCwKICAgIGludGVncmF0ZWQgd2l0aCB0aGUgRUNNIHBsYXRmb3JtIChlZGl0LCBjaGVjay1pbiwgY2hlY2stb3V0LCBwcm9wZXJ0aWVzLCBldGMuKSBhY3Rpb25zIG1vZGVsLiBBY3Rpb25zIGhhdmUgdG8gYmUgaW50ZWdyYXRlZCB3aXRoIEVjbGlwc2UncyBtZW51aXRlbXMgLyB2aWV3cyBtb2RlbC48L2xpPgoKICAgIDxsaT5BIHBsdWdnYWJsZSA8c3Ryb25nPnVuaWZpZWQgc2VjdXJpdHkgbW9kZWw8L3N0cm9uZz4gYmFzZWQgb24KICAgIHJvbGVzL3Blcm1pc3Npb25zIHRoYXQgY2FuIGJlIGVhc2lseSBpbnRlZ3JhdGVkIHdpdGggdGhlIEVDTSBwbGF0Zm9ybQogICAgKG9uIHRoZSBzZXJ2ZXIpLiBXZSBhcmUgY3VycmVudGx5IGludmVzdGlnYXRpbmcgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9oaWdnaW5zLyI+RVRGL0hpZ2dpbnM8L2E+IGFuZCA8YSBocmVmPSJodHRwOi8vYWNlZ2lzZWN1cml0eS5vcmcvIj5BY2VnaTwvYT4gZm9yIHRoaXMgcGFydC48L2xpPgoKICAgIDxsaT5BbiA8c3Ryb25nPkluZGV4aW5nIGFuZCBzZWFyY2ggc2VydmljZTwvc3Ryb25nPiB3aWxsIGJlIHByb3ZpZGVkIGJ5IEphY2tSYWJiaXQgYnVpbHQtaW4gaW5kZXggYW5kIHNlYXJjaCBmZWF0dXJlcy4gQXBvZ+llIG1heSBhbGxvdyBkZXZlbG9wZXJzIHRvIHBsdWcgb3RoZXIgc2VhcmNoIGVuZ2luZXMsIHRoYXQgY291bGQgYmUgbmVlZGVkIGZvciBzcGVjaWFsaXplZCBuZWVkcy48L2xpPgoKICAgIDxsaT5BIHJlbGF0aW9uIHNlcnZpY2UgdG8gaGFuZGxlIHJlbGF0aW9uIGJldHdlZW4gcmVzb3VyY2VzCiAgICAgICAgKDxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1JERi8iPlJERjwvYT4gYmFzZWQpLiBUaGlzIGNvbXBvbmVudCBtYXkgYmUgYmFzZWQgb24gPGEgaHJlZj0iaHR0cDovL3d3dy5vcGVucmRmLm9yZy8iPlNlc2FtZTwvYT4uIFRoaXMgc2VydmljZSBzaG91bGQgYmUgaW5kZXBlbmRhbnQgZnJvbSB0aGUgY29udGVudCByZXBvc2l0b3J5LjwvbGk+CgogICAgPGxpPkEgY29tbXVuaWNhdGlvbiBzZXJ2aWNlIHRoYXQgY2FuIGJlIHVzZWQgYnkKICAgIGNvbXBvbmVudHMgdG8gY29tbXVuaWNhdGUgd2l0aCB0aGUgRUNNIHBsYXRmb3JtIGFuZCBvdGhlciBjb21wb25lbnQgb2YgdGhlIGluZm9ybWF0aW9uIHN5c3RlbS4gVGhpcyBjb21wb25lbnQgd2lsbCB1c2UgdGhlIDxhIGhyZWY9Imh0dHA6Ly8gd3d3LmVjbGlwc2Uub3JnL2VjZiI+RWNsaXBzZSBDb21tdW5pY2F0aW9uIEZyYW1ld29yazwvYT4gKEVDRikgKGFuZCBwcm90b2NvbHMgbGlrZSA8YSBocmVmPSJodHRwOi8vd3d3LnhtcHAub3JnL1hNUFAiPlhNUFA8L2E+IC8gPGEgaHJlZj0KICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi9zb2FwLyI+U09BUDwvYT4gLyBYTUwtUlBDIG9yIDxhIGhyZWY9Imh0dHA6Ly9qYXZhLnN1bi5jb20vcHJvZHVjdHMvam1zLyI+Sk1TPC9hPikuPC9saT4KCiAgICA8bGk+QSBzdWJzY3JpcHRpb24tYmFzZWQgPHN0cm9uZz51c2VyIG5vdGlmaWNhdGlvbjwvc3Ryb25nPiBtZWNoYW5pc20gKHRvIGFsbG93IHRoZSB1c2VyIHRvIGJlCiAgICBub3RpZmllZCBieSB0aGUgRUNNIHBsYXRmb3JtIHRocm91Z2ggdmFyaW91cyBjaGFubmVscyBsaWtlIFVJIGdsaXRjaGVzIChleDogd2luZG93cyB0cmF5KSwgZW1haWwsIGluc3RhbnQgbWVzc2FnaW5nIChvciBTTVMpIHdoZW4gZXZlbnRzIG9jY3VyLiBUaGlzIHNlcnZpY2UgbWF5IGJlIGJhc2VkIG9uIEVDRi48L2xpPgoKICAgPGxpPkEgc2VydmljZSB0byBoYW5kbGUgPHN0cm9uZz5vbmxpbmUvb2ZmbGluZSBtb2RlPC9zdHJvbmc+IGFuZCBlbmFibGluZy9kaXNhYmxpbmcKICAgIGFjdGlvbnMvY2FwYWJpbGl0aWVzIGFjY29yZGluZyB0byB0aGUgY29ubmV4aW9uIGF2YWlsYWJpbGl0eS4gVGhpcyBoYXMgdG8gcHJvdmlkZSBsb2NhbCBhbmQgcmVtb3RlIGNvbnRlbnQgcmVwb3NpdG9yeSBzeW5jaHJvbmlzYXRpb24uIFN5bmNNTCAodGhyb3VnaCBTeW5jNEovRnVuYW1ib2wpIG1heSBiZSB1c2VkIGhlcmUuPC9saT4KCiAgICA8bGk+QSA8c3Ryb25nPmRpZ2l0YWwgc2lnbmF0dXJlIHNlcnZpY2U8L3N0cm9uZz4gdG8gc2lnbiBkb2N1bWVudHMgYW5kIHdvcmtmbG93CiAgICBhY3Rpb25zLjwvbGk+CgogIDwvdWw+CgogIDxoMz5BcHBsaWNhdGlvbiBQbGF0Zm9ybTwvaDM+CgogIDx1bD4KICAgIDxsaT48c3Ryb25nPk1haWwgY2xpZW50IGNvbXBvbmVudDwvc3Ryb25nPiB0aGF0IGNhbiBiZSB1c2VkIHRvIGNyZWF0ZSBhIHNwZWNpZmljLAogICAgYnVzaW5lc3Mtb3JpZW50ZWQsIG1haWwgY2xpZW50IChmb3IgZXhhbXBsZSA6IGN1c3RvbSBtYWlsLWJhc2VkCiAgICBhcHBsaWNhdGlvbiBsaWtlIHdvcmtmbG93LWJhc2VkIGNvbGxhYm9yYXRpdmUgbWFpbCBtYW5hZ2VtZW50IG9yIENSTSBhcHBsaWNhdGlvbikuPC9saT4KCiAgICA8bGk+PHN0cm9uZz5DYWxlbmRhciBjb21wb25lbnQ8L3N0cm9uZz4gKGN1c3RvbWl6YWJsZSB0byBjcmVhdGUgY2FsZW5kYXItc3R5bGUKICAgIGFwcGxpY2F0aW9uIGxpa2UgcGxhbm5pbmcgbWFuYWdlbWVudCkuPC9saT4KCiAgICA8bGk+PHN0cm9uZz5JbnN0YW50IE1lc3NhZ2luZyBjb21wb25lbnQ8L3N0cm9uZz4gKHByZXNlbmNlIGFuZCBzeW5jaHJvbm91cyBjb21tdW5pY2F0aW9uIGJldHdlZW4KICAgIHVzZXJzLCB1c2VyIG5vdGlmaWNhdGlvbiBjaGFubmVsKS4gVGhpcyB3b3VsZCBiZSBiYXNlZCBvbiBFQ0YuPC9saT4KCiAgICA8bGk+PHN0cm9uZz5SaWNoIGRvY3VtZW50IGVkaXRvcjwvc3Ryb25nPiAoYmFzZWQgb24gWEhUTUwpIHRoYXQgY2FuIGJlIHVzZWQgdG8gY3JlYXRlCiAgICBjdXN0b20gY29udGVudCBlZGl0b3JzIChmb3IgZXhhbXBsZSBhIGN1c3RvbSA8YSBocmVmPQogICAgImh0dHA6Ly93d3cubmV3c21sLm9yZy9wYWdlcy9pbmRleC5waHAiPk5ld3NNTDwvYT4gZG9jdW1lbnQKICAgIGVkaXRvciBvciBhIERvY0Jvb2sgb25lKS48L2xpPgoKICAgIDxsaT48c3Ryb25nPkNvbGxhYm9yYXRpdmUgd29ya3NwYWNlczwvc3Ryb25nPiAodGhhdCB3b3VsZCBvZmZlciBhY2Nlc3MgdG8gY29sbGFib3JhdGl2ZQogICAgd29ya3NwYWNlcyBvbiB0aGUgRUNNIHBsYXRmb3JtKS48L2xpPgoKICAgIDxsaT48c3Ryb25nPlN5bmNocm9ub3VzIGRvY3VtZW50PC9zdHJvbmc+IGVkaXRpbmcgKHBsdWdnZWQgaW50byB0aGUgZG9jdW1lbnQKICAgIGVkaXRvcikuPC9saT4KCiAgICA8bGk+PHN0cm9uZz5Bbm5vdGF0aW9uIHNlcnZpY2U8L3N0cm9uZz4gKHRoYXQgbWF5IGJlIGJhc2VkIG9uIDxhIGhyZWY9CiAgICAiaHR0cDovL3d3dy53My5vcmcvMjAwMS9Bbm5vdGVhLyI+QW5ub3RlYTwvYT4pLjwvbGk+CgogICAgPGxpPjxzdHJvbmc+VGFnZ2luZyBhbmQgY2F0ZWdvcml6YXRpb248L3N0cm9uZz4gc2VydmljZS48L2xpPgoKICAgIDxsaT48c3Ryb25nPlJlcG9ydGluZyBzZXJ2aWNlPC9zdHJvbmc+IChCSVJUIGJhc2VkKSB0byBhbGxvdyB0aGUgY3JlYXRpb24gb2YgYWN0aXZpdHkgcmVwb3J0cy48L2xpPgogIDwvdWw+CgogIDxoMj5FeGlzdGluZyBzdGFuZGFyZHMgYW5kIHByb2plY3RzIGxldmVyYWdlZDwvaDI+CgogIDxwPlRoaXMgcHJvamVjdCB3aWxsIGJlIGJhc2VkIG9uIGEgbnVtYmVyIG9mIGhpZ2gtcXVhbGl0eSBvcGVuIHNvdXJjZSBmcmFtZXdvcms6PC9wPgoKICA8dWw+CiAgICA8bGk+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9yY3AiPkVjbGlwc2UgUkNQPC9hPiAoaW5mcmFzdHJ1Y3R1cmUsIFVJLAogICAgUGVyc3BlY3RpdmVzLCBPU0dpIGNvcmUsIGV0Yy4pPC9saT4KCiAgICA8bGk+PGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9lY2YiPkVjbGlwc2UgRUNGPC9hPiB0byBoYW5kbGUKICAgIGNsaWVudC9zZXJ2ZXIgY29tbXVuaWNhdGlvbiwgSU0gYW5kIGNvbW11bmljYXRpb24gbmVlZHM8L2xpPgoKICAgIDxsaT48YSBocmVmPQogICAgImh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvd2VidG9vbHMvd3N0L21haW4uaHRtbCI+RWNsaXBzZQogICAgV1RQL1dTVDwvYT4gdG8gaGFuZGxlIHdlYiBzZXJ2aWNlcyAoWFNEIGFuZCBTT0FQL1dTREwgc3VwcG9ydCk8L2xpPgoKICAgIDxsaT48YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2dlZi8iPkVjbGlwc2UgR0VGPC9hPiB0bwogICAgaGFuZGxlIGdyYXBoaWMtYmFzZWQgdXNlciBpbnRlcmZhY2VzIChyZWxhdGlvbiB2aXN1YWxpemF0aW9uIGFuZAogICAgbWFuYWdlbWVudCBmb3IgZXhhbXBsZSk8L2xpPgoKICAgIDxsaT48YSBocmVmPSJodHRwOi8vamFja3JhYmJpdC5hcGFjaGUub3JnIj5BcGFjaGUgSmFja1JhYmJpdDwvYT4gYW5kIDxhIGhyZWY9Imh0dHA6Ly93d3cuZGI0by5jb20iPmRiNG88L2E+IGZvciBzdG9yYWdlPC9saT4KCiAgICA8bGk+PGEgaHJlZj0iaHR0cDovL2VjbGlwc2Uub3JnL2JpcnQvIj5FY2xpcHNlIEJJUlQ8L2E+IGZvciB0aGUKICAgIHJlcG9ydGluZyBzZXJ2aWNlPC9saT4KCiAgICA8bGk+PGEgaHJlZj0iaHR0cDovL3d3dy5zeW5jNGoub3JnLyI+T2JqZWN0V2ViIFN5bmM0SjwvYT4gZm9yCiAgICB0aGUgc3luY2hyb25pemF0aW9uIHNlcnZpY2U8L2xpPgoKICAgIDxsaT48YSBocmVmPSJodHRwOi8vbHVjZW5lLmFwYWNoZS5vcmcvamF2YS9kb2NzL2luZGV4Lmh0bWwiPkFwYWNoZQogICAgTHVjZW5lPC9hPiBmb3IgdGhlIHNlYWNoIHNlcnZpY2U8L2xpPgoKICAgIDxsaT48YSBocmVmPSJodHRwOi8vd3d3Lm9wZW5yZGYub3JnLyI+T3BlblJERiBTZXNhbWU8L2E+IGZvciB0aGUKICAgIHJlbGF0aW9uIHNlcnZpY2UgLyBSREYgZGF0YWJhc2U8L2xpPgoKICA8L3VsPgoKICA8cD5UaGlzIHByb2plY3Qgd2lsbCBiZSBoZWF2aWx5IGJhc2VkIG9uIG9wZW4gc3RhbmRhcmQgOjwvcD4KCiAgPHVsPgogICAgPGxpPjxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1hNTC9TY2hlbWFYTUwiPlczQyBYTUxTY2hlbWE8L2E+IGZvcgogICAgY29udGVudC9kYXRhIHNjaGVtYXM8L2xpPgoKICAgIDxsaT48YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9NYXJrVXAvRm9ybXMvIj5XM0MgWEZvcm1zPC9hPiBmb3IKICAgIGZvcm1zIHByb3ZpZGVkIGJ5IHRoZSBFQ00gcGxhdGZvcm0gKGVkaXQgdmlldywgd29ya2Zsb3cgYWN0aW9ucyBmb3Jtcywgc2VhcmNoIGZvcm0sIGV0Yy4pPC9saT4KICAgIAogICAgPGxpPjxhIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1JERi8iPlJERjwvYT4gYXMgcmVsYXRpb24gZm9ybWF0PC9saT4KCiAgICA8bGk+PGEgaHJlZj0iaHR0cDovL3d3dy54bXBwLm9yZy8iPlhNUFA8L2E+IGFzIGNvbW11bmljYXRpb24KICAgIHByb3RvY29sIC8gWE1MIGJ1cyAvIGV2ZW50IGNoYW5uZWw8L2xpPgoKICAgIDxsaT48YSBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi9zb2FwLyI+U09BUDwvYT48L2xpPgoKICA8L3VsPgoKICA8aDI+T3JnYW5pemF0aW9uPC9oMj4KCiAgPHA+VGhpcyBwcm9qZWN0IHdpbGwgYmUgb3JnYW5pemVkIGludG8gMiB0b3AtbGV2ZWwgY29tcG9uZW50cyA6PC9wPgoKICA8dWw+CiAgICA8bGk+Q29yZSBQbGF0Zm9ybSAoQ1ApIDogYnVpbGQgYWxsIGNvcmUgc2VydmljZXMgbGlrZSBkYXRhIHN0b3JhZ2UsCiAgICByZWxhdGlvbiwgZm9ybSwgY29udGVudCB0eXBlLCBpbmRleGluZyAvIHNlYXJjaCwgY29tbXVuaWNhdGlvbiwKICAgIHN5bmNocm9uaXphdGlvbiwgZXRjLjwvbGk+CgogICAgPGxpPkFwcGxpY2F0aXZlIFBsYXRmb3JtIChBUCkgOiBtYWlsIGNsaWVudCwgY2FsZW5kYXJpbmcsIHJpY2ggdGV4dAogICAgZWRpdG9yLCB3b3JrZmxvdyBlZGl0b3IsIGNvbGxhYm9yYXRpdmUgd29ya3NwYWNlcywgZGlnaXRhbCBzaWduYXR1cmUsCiAgICBJTSwgZXRjLjwvbGk+CiAgPC91bD4KCiAgICA8aDM+UHJvcG9zZWQgaW5pdGlhbCBjb21taXR0ZXJzIGFuZCBwcm9qZWN0IGxlYWQ8L2gzPgogICAgCiAgICA8cD5UaGUgaW5pdGlhbCBjb21taXR0ZXJzIHdpbGwgZm9jdXMgb24gZGV2ZWxvcGluZyBhbmQgY3JlYXRpbmcgY29yZSBzZXJ2aWNlcy4gVGhlIGFnaWxlIGRldmVsb3BtZW50IHByb2Nlc3MgYWRvcHRlZCB3aWxsIGZvbGxvdyBlY2xpcHNlLm9yZydzIHN0YW5kYXJkcyBmb3Igb3Blbm5lc3MgYW5kIHRyYW5zcGFyZW5jeS4gIE91ciBnb2FsIGlzIHRvIHByb3ZpZGUgdGhlIGluZnJhc3RydWN0dXJlIGFuZCBBUElzIG5lZWRlZCB0byBidWlsZCBhIHN0cm9uZyBkZXZlbG9wZXIgY29tbXVuaXR5IHRoYXQgd291bGQgZW1wb3dlciB0aGUgcGxhdGVmb3JtIHRvIG1ha2UgaXQgcXVpY2tseSBncm93LiBUaGUgaW5pdGlhbCBjb21taXR0ZXJzIGFyZToKICAgIAo8dWw+CiAgPGxpPkVyaWMgQmFycm9jYSAoJiMxMDE7JiMwOTg7JiMwNjQ7JiMxMTA7JiMxMTc7JiMxMjA7JiMxMDE7JiMxMTE7JiMwNDY7JiMwOTk7JiMxMTE7JiMxMDk7KSA6IHByb2plY3QgbWFuYWdlcjwvbGk+CiAgCiA8bGk+Qm9nZGFuIFN0ZWZhbmVzY3UgKCYjMDk4OyYjMTE1OyYjMDY0OyYjMTEwOyYjMTE3OyYjMTIwOyYjMTAxOyYjMTExOyYjMDQ2OyYjMDk5OyYjMTExOyYjMTA5Oyk6IHRlY2huaWNhbCBsZWFkZXI8L2xpPgogCiA8bGk+RXVnZW4gSW9uaWNhIChOdXhlbyk6IHJlbGF0aW9uIGFuZCBzZWFyY2ggc2VydmljZXM8L2xpPgogCiA8bGk+QyZlYWN1dGU7ZHJpYyBCb3Nkb25uYXQgKE51eGVvKTogY29udGVudCBlZGl0b3JzIGFuZCBzeW5jaHJvbml6YXRpb248L2xpPgogCiA8bGk+Q2FybCBSb3NlbmJlcmdlciAoZGI0b2JqZWN0cyk6IHN0b3JhZ2Ugc2VydmljZTwvbGk+CjwvdWw+CgoKICA8cD5JbnRlcmVzdGVkIHBvdGVudGlhbCBjb21taXRlcnMgYXJlIGtpbmR5IGludml0ZWQgdG8gZXhwcmVzcyBpdCBvbiB0aGUgbmV3c2dyb3VwIG9yIHZpYSBlbWFpbC48L3A+CiAgCiAgCiAgPGgzPkludGVyZXN0ZWQgcGFydGllczwvaDM+CiA8cD5JbnRlcmVzdCBoYXZlIGJlZW4gbm90aWZpZWQgYnkgZm9sbHdvaW5nIG9yZ2FuaXphdGlvbiBzbyBmYXI6PC9wPgogPHVsPgogPGxpPjxhIGhyZWY9Imh0dHA6Ly93d3cuYWZwLmNvbS8iPkFGUDwvYT4gKGNvbnN1bWVyKTwvbGk+CiA8bGk+PGEgaHJlZj0iaHR0cDovL3d3dy5jaGFsbWVycy5zZS8iPkNoYWxtZXJzIFVuaXZlcnNpdHkgb2YgVGVjaG5vbG9neTwvYT4gKGNvbnN1bWVyIC8gY29tbWl0ZXIpPC9saT4KIDxsaT48YSBocmVmPSJodHRwOi8vd3d3LmNuY2MuZnIiPkZyZW5jaCBJbnN0aXR1dGUgb2YgU3RhdHV0b3J5IEF1ZGl0b3JzPC9hPiAoY29uc3VtZXIpPC9saT4KIDxsaT48YSBocmVmPSJodHRwOi8vd3d3LmRiNG9iamVjdHMuY29tIj5kYjRvYmplY3RzPC9hPiAoY29tbWl0ZXIpPC9saT4KIDxsaT48YSBocmVmPSJodHRwOi8vdG10ZWMuYml6L2luZGV4Lmh0bWwiPlRNVDwvYT4gKGNvbnN1bWVyIC8gY29tbWl0ZXIpIDwvbGk+CiA8L3VsPgogPHA+VG8gZXhwcmVzcyBzdXBwb3J0LCBjb25jZXJuLCBvciBjb25zdHJ1Y3RpdmUgb3BpbmlvbiByZWdhcmRpbmcgdGhlIGZvcm1hdGlvbiBvZiB0aGlzIHByb3Bvc2VkIHRlY2hub2xvZ3kgcHJvamVjdCwgYWxsIGFyZSBlbmNvdXJhZ2VkIHRvIHV0aWxpemUgdGhlIG5ld3Nncm91cC48L3A+IAoKCiAgICA8aDM+SW5pdGlhbCBjb250cmlidXRpb248L2gzPgogICAgPHA+VGhlIGN1cnJlbnQgc291cmNlIGNvZGUgYW5kIGRvY3VtZW50YXRpb24gcmVwb3NpdG9yeSBmb3IgdGhpcyBwcm9qZWN0IGN1cnJlbnRseSBsaXZlIGhlcmUgOiA8YSBocmVmPSJodHRwOi8vc3ZuLm51eGVvLm9yZy90cmFjL3B1Yi9icm93c2VyL0Fwb2dlZS8iPmh0dHA6Ly9zdm4ubnV4ZW8ub3JnL3RyYWMvcHViL2Jyb3dzZXIvQXBvZ2VlLzwvYT4gKGRpcmVjdCBTVk4gYWNjZXNzIDogPGEgaHJlZj0iaHR0cDovL3N2bi5udXhlby5vcmcvcHViL0Fwb2dlZSI+aHR0cDovL3N2bi5udXhlby5vcmcvcHViL0Fwb2dlZTwvYT4pLiBBIHdlYnNpdGUgaXMgYWxzbyBhdmFpbGFibGUgZm9yIGRvY3VtZW50YXRpb24gcHVibGlzaGluZzogPGEgaHJlZj0iaHR0cDovL2Fwb2dlZS5udXhlby5vcmciPmFwb2dlZS5udXhlLm9yZzwvYT48L3A+CgoKICA8aDI+Um9hZG1hcDwvaDI+CgogIDxwPkRldmVsb3BtZW50IG1vZGVsIGlzIHRpbWUgYmFzZWQuIE1ham9yIHJlbGVhc2UgY3ljbGUgaXMgeWVhcmx5LjwvcD4KCiAgPGgzPjEuMDwvaDM+CgogIDx1bD4KICAgIDxsaT48c3Ryb25nPk0xIC0gQXByaWwgMjAwNjwvc3Ryb25nPgoKICAgICAgPHVsPgogICAgICAgIDxsaT5bQ1BdIFRlY2huaWNhbCBzcGVjaWZpY2F0aW9ucyBvZiB0aGUgY29yZSBwbGF0Zm9ybSAoNjAlCiAgICAgICAgZG9uZSk8L2xpPgoKICAgICAgICA8bGk+W0NQXSBSZXNvdXJjZSBtb2RlbCAoZG9uZcKgJm1kYXNoO8KgY3VycmVudGx5IGJlaW5nIHJlZmFjdG9yZWQgb24gdG9wIG9mIEphY2tSYWJiaXQpPC9saT4KCiAgICAgICAgPGxpPltDUF0gUmVsYXRpb24gc2VydmljZSAvIFJERiAoZG9uZSk8L2xpPgoKICAgICAgICA8bGk+W0NQXSBJbmRleGluZyBhbmQgU2VhcmNoIHNlcnZpY2UgLyBMdWNlbmUgKGRvbmUpPC9saT4KCiAgICAgICAgPGxpPltDUF0gUmljaCBDb250ZW50IGVkaXRvcnMgKE1TV29yZCwgT3Blbk9mZmljZSwgWEhUTUwpIChkb25lKTwvbGk+CiAgICAgICAgCiAgICAgICAgPGxpPltDUF0gRWNsaXBzZSBGb3JtcyBnZW5lcmF0aW9uIHNlcnZpY2UgKFhGb3JtcyBiYXNlZCwgYWxwaGEgc3VwcG9ydCwgZG9uZSk8L2xpPgogICAgICAgIAogICAgICAgIDxsaT5bQ1BdIE9uLXRoZS1mbHkgdmFsaWRhdGlvbiBvZiBhIFNXVCBmb3JtIHdpdGggYSBYTUwgU2NoZW1hIChYU0QpIChkb25lKTwvbGk+IAogICAgICA8L3VsPgogICAgPC9saT4KCiAgICA8bGk+PHN0cm9uZz5NMiAtIEp1bmUgMjAwNjwvc3Ryb25nPgoKICAgICAgPHVsPgogICAgICAgIDxsaT5bQ1BdIENvbW11bmljYXRpb24gc2VydmljZSAoWE1MLVJQQyBiYXNlZCk8L2xpPgoKICAgICAgICA8bGk+W0NQXSBJbnRlZ3JhdGlvbiBvZiBzZXJ2ZXItZGVmaW5lZCBhY3Rpb25zIGF2YWlsYWJsZSBvbgogICAgICAgIHJlc291cmNlcyAoZG9jdW1lbnRzKTwvbGk+CgogICAgICAgIDxsaT5bQ1BdIENvbnRlbnQgdHlwZSBzZXJ2aWNlICh1c2UgY29udGVudCB0eXBlcwogICAgICAgIGRlZmluZWQgYnkgdGhlIHNlcnZlciB3aXRoIFhTRCk8L2xpPgoKICAgICAgICA8bGk+W0FQXSBDb2xsYWJvcmF0aXZlIHdvcmtzcGFjZXM8L2xpPgogICAgICAgIAogICAgICAgIDxsaT5bQ1BdIFJpY2ggVGV4dCBFZGl0b3IgKGRvbmUpPC9saT4KICAgICAgICAKICAgICAgPC91bD4KICAgIDwvbGk+CgogICAgPGxpPjxzdHJvbmc+TTMgLSBBdWd1c3QgMjAwNjwvc3Ryb25nPgoKICAgICAgPHVsPgogICAgICAgIDxsaT5bQ1BdIFNlY3VyaXR5IG1vZGVsIGFuZCBzZXJ2aWNlPC9saT4KCiAgICAgICAgPGxpPltDUF0gRm9ybSBzZXJ2aWNlIChYRm9ybSBmdWxsIHN1cHBvcnQpPC9saT4KCiAgICAgICAgPGxpPltDUF0gQ2xpZW50IC8gU2VydmVyIHN5bmNocm9uaXphdGlvbiAtJmd0OyBvbmxpbmUvb2ZmbGluZQogICAgICAgIG1vZGU8L2xpPgogICAgICA8L3VsPgogICAgPC9saT4KCiAgICA8bGk+PHN0cm9uZz5NNCAtIFNlcHRlbWJlciAyMDA2PC9zdHJvbmc+CgogICAgICA8dWw+CiAgICAgICAgPGxpPltDUF0gQ29tbXVuaWNhdGlvbiBmcmFtZXdvcmsgKFNPQVAgc3VwcG9ydCk8L2xpPgoKICAgICAgICA8bGk+W0FQXSBJbnN0YW50IE1lc3NhZ2luZyAoWE1QUCBiYXNlZCk8L2xpPgoKICAgICAgICA8bGk+W0FQXSBNYWlsIGNsaWVudCAoYWxwaGEpPC9saT4KCiAgICAgICAgPGxpPltBUF0gQ2FsZW5kYXIgY2xpZW50IChhbHBoYSk8L2xpPgogICAgICA8L3VsPgogICAgPC9saT4KCiAgICA8bGk+PHN0cm9uZz5SQyAtIE9jdG9iZXIgMjAwNjwvc3Ryb25nPgoKICAgICAgPHVsPgogICAgICAgIDxsaT5GZWF0dXJlIGZyZWV6ZTwvbGk+CiAgICAgIDwvdWw+CiAgICA8L2xpPgoKICAgIDxsaT48c3Ryb25nPkZpbmFsIC0gRGVjZW1iZXIgMjAwNjwvc3Ryb25nPjwvbGk+CiAgPC91bD4KCiAgPGgyPjIuMCAtIFNlcHRlbWJlciAyMDA3PC9oMj4KCiAgPHVsPgogICAgPGxpPltBUF0gRGlnaXRhbCBzaWduYXR1cmU8L2xpPgoKICAgIDxsaT5bQVBdIFJlcG9ydGluZyBzZXJ2aWNlPC9saT4KCiAgICA8bGk+W0FQXSBNYWlsIGNvbXBvbmVudCAoY29tcGxldGUpPC9saT4KCiAgICA8bGk+W0FQXSBDYWxlbmRhciBjb21wb25lbnQgKGNvbXBsZXRlKTwvbGk+CgogICAgPGxpPltBUF0gUmVsYXRpb24gbWFuYWdlbWVudCAocmVsYXRpb24gZ3JhcGhzLCB2aXN1YWwgcmVsYXRpb24KICAgIG1hbmFnZW1lbnQpPC9saT4KCiAgICA8bGk+W0FQXSBTeW5jaHJvbm91cyBjb2xsYWJvcmF0aXZlIHJpY2ggZG9jdW1lbnQgZWRpdGlvbjwvbGk+CgogICAgPGxpPltDUF0gQW5ub3RhdGlvbiBzZXJ2aWNlPC9saT4KICA8L3VsPgoKICAgICAgPC9kaXY+CiAgPC9kaXY+CiAgCjw/cGhwCgkjIFBhc3RlIHlvdXIgSFRNTCBjb250ZW50IGJldHdlZW4gdGhlIEVPSFRNTCBtYXJrZXJzIQkKCSRodG1sID0gb2JfZ2V0X2NvbnRlbnRzKCk7CglvYl9lbmRfY2xlYW4oKTsKCgkjIEdlbmVyYXRlIHRoZSB3ZWIgcGFnZQoJJEFwcC0+Z2VuZXJhdGVQYWdlKCR0aGVtZSwgJE1lbnUsICROYXYsICRwYWdlQXV0aG9yLCAkcGFnZUtleXdvcmRzLCAkcGFnZVRpdGxlLCAkaHRtbCk7Cj8+Cg==