ZGlmZiAtLWdpdCBhLy5wcm9qZWN0IGIvLnByb2plY3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDJiYTE4ZgotLS0gL2Rldi9udWxsCisrKyBiLy5wcm9qZWN0CkBAIC0wLDAgKzEsMjIgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8cHJvamVjdERlc2NyaXB0aW9uPgorCTxuYW1lPm9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmFnZ3JlZ2F0b3I8L25hbWU+CisJPGNvbW1lbnQ+PC9jb21tZW50PgorCTxwcm9qZWN0cz4KKwk8L3Byb2plY3RzPgorCTxidWlsZFNwZWM+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5tMmUuY29yZS5tYXZlbjJCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5zb25hcmxpbnQuZWNsaXBzZS5jb3JlLnNvbmFybGludEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCTwvYnVpbGRTcGVjPgorCTxuYXR1cmVzPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLm0yZS5jb3JlLm1hdmVuMk5hdHVyZTwvbmF0dXJlPgorCTwvbmF0dXJlcz4KKzwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvYWJvdXQuaHRtbCBiL2Fib3V0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjRjMDU5OAotLS0gL2Rldi9udWxsCisrKyBiL2Fib3V0Lmh0bWwKQEAgLTAsMCArMSwyOCBAQAorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIKKyAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiLz4KKzx0aXRsZT5BYm91dDwvdGl0bGU+Cis8L2hlYWQ+Cis8Ym9keSBsYW5nPSJFTi1VUyI+Cis8aDI+QWJvdXQgVGhpcyBDb250ZW50PC9oMj4KKyAKKzxwPkp1bmUgMSwgMjAxNjwvcD4JCis8aDM+TGljZW5zZTwvaDM+CisKKzxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAoJnF1b3Q7Q29udGVudCZxdW90OykuICBVbmxlc3Mgb3RoZXJ3aXNlIAoraW5kaWNhdGVkIGJlbG93LCB0aGUgQ29udGVudCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZQorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIGF2YWlsYWJsZSAKK2F0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCitGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgorCis8cD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSBDb250ZW50IGlzIAorYmVpbmcgcmVkaXN0cmlidXRlZCBieSBhbm90aGVyIHBhcnR5ICgmcXVvdDtSZWRpc3RyaWJ1dG9yJnF1b3Q7KSBhbmQgZGlmZmVyZW50IHRlcm1zIGFuZCBjb25kaXRpb25zIG1heQorYXBwbHkgdG8geW91ciB1c2Ugb2YgYW55IG9iamVjdCBjb2RlIGluIHRoZSBDb250ZW50LiAgQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIAorcHJvdmlkZWQgd2l0aCB0aGUgQ29udGVudC4gIElmIG5vIHN1Y2ggbGljZW5zZSBleGlzdHMsIGNvbnRhY3QgdGhlIFJlZGlzdHJpYnV0b3IuICBVbmxlc3Mgb3RoZXJ3aXNlCitpbmRpY2F0ZWQgYmVsb3csIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRVBMIHN0aWxsIGFwcGx5IHRvIGFueSBzb3VyY2UgY29kZSBpbiB0aGUgQ29udGVudAorYW5kIHN1Y2ggc291cmNlIGNvZGUgbWF5IGJlIG9idGFpbmVkIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnPC9hPi48L3A+CisKKzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9qZW5raW5zLmJ1aWxkLmNvbmZpZy54bWwgYi9qZW5raW5zLmJ1aWxkLmNvbmZpZy54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmNhY2ViOQotLS0gL2Rldi9udWxsCisrKyBiL2plbmtpbnMuYnVpbGQuY29uZmlnLnhtbApAQCAtMCwwICsxLDIyIEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzwhLS0jIENvcHlyaWdodCAoYykgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtLT4KKzwhLS0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgCQkgLS0+Cis8IS0tIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgIC0tPgorPCEtLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAtLT4KKzwhLS0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLS0+Cis8IS0tIyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0tPgorPCEtLSMgQ29udHJpYnV0b3JzOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtLT4KKzwhLS0jIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uICAgICAgICAgICAgICAgICAgICAgICAgICAgLS0+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorPCEtLSMgTW9kdWxlIHNwZWNpZmljIHBhcmFtZXRlcnMgZm9yIHRoZSBKZW5raW5zIEpvYiAJCQkJCQkgLS0+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorCis8amVua2lucz4KKyAgICAKKwk8IS0tIERPIE5PVCBFRElUIEJFTE9XIFRISVMgTElORSAtLT4KKyAgICAgICAgPGplbmtpbnMuYnVpbGQuZGVwZW5kZW5jaWVzPgorICAgICAgICAgICAgICAgIDxqZW5raW5zLmJ1aWxkLmRlcGVuZGVuY3k+b3JnLmVjbGlwc2Uub3NicC5kc2w8L2plbmtpbnMuYnVpbGQuZGVwZW5kZW5jeT4KKyAgICAgICAgICAgICAgICA8amVua2lucy5idWlsZC5kZXBlbmRlbmN5Pm9yZy5lY2xpcHNlLm9zYnAuZWN2aWV3LmNvcmU8L2plbmtpbnMuYnVpbGQuZGVwZW5kZW5jeT4KKyAgICAgICAgPC9qZW5raW5zLmJ1aWxkLmRlcGVuZGVuY2llcz4KKzwvamVua2lucz4KZGlmZiAtLWdpdCBhL25vdGljZS5odG1sIGIvbm90aWNlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzNkMzRjMwotLS0gL2Rldi9udWxsCisrKyBiL25vdGljZS5odG1sCkBAIC0wLDAgKzEsMTA3IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJJU08tODg1OS0xIiA/PgorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXN0cmljdC5kdGQiPgorPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIiAvPgorPHRpdGxlPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvdGl0bGU+Cis8L2hlYWQ+CisKKzxib2R5IGxhbmc9IkVOLVVTIj4KKzxoMj5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L2gyPgorPHA+QXByaWwgOSwgMjAxNDwvcD4KKworPGgzPlVzYWdlIE9mIENvbnRlbnQ8L2gzPgorCis8cD5USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMKKyAgIChDT0xMRUNUSVZFTFkgJnF1b3Q7Q09OVEVOVCZxdW90OykuICBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVSBBR1JFRSBUSEFUIFlPVVIgVVNFCisgICBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUgorICAgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC48L3A+CisKKzxoMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9oMz4KKworPHA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMAorICAgKCZxdW90O0VQTCZxdW90OykuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXMgQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9hPi4KKyAgIEZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAmcXVvdDtQcm9ncmFtJnF1b3Q7IHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+CisKKzxwPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCBkb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gc291cmNlIGNvZGUKKyAgIHJlcG9zaXRvcnkgKCZxdW90O1JlcG9zaXRvcnkmcXVvdDspIGluIHNvZnR3YXJlIG1vZHVsZXMgKCZxdW90O01vZHVsZXMmcXVvdDspIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCZxdW90O0Rvd25sb2FkcyZxdW90OykuPC9wPgorCis8dWw+CisgICAgICAgPGxpPkNvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoJnF1b3Q7UGx1Zy1pbnMmcXVvdDspLCBwbHVnLWluIGZyYWdtZW50cyAoJnF1b3Q7RnJhZ21lbnRzJnF1b3Q7KSwgYW5kIGZlYXR1cmVzICgmcXVvdDtGZWF0dXJlcyZxdW90OykuPC9saT4KKyAgICAgICA8bGk+RWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhJnRyYWRlOyBBUmNoaXZlKSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtwbHVnaW5zJnF1b3Q7LjwvbGk+CisgICAgICAgPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7ZmVhdHVyZXMmcXVvdDsuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zCisgICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KKyAgICAgICA8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoJnF1b3Q7SW5jbHVkZWQgRmVhdHVyZXMmcXVvdDspLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuPC9saT4KKzwvdWw+CisKKzxwPlRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2Fib3V0Lmh0bWwmcXVvdDsgKCZxdW90O0Fib3V0cyZxdW90OykuIFRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kCitJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2xpY2Vuc2UuaHRtbCZxdW90OyAoJnF1b3Q7RmVhdHVyZSBMaWNlbnNlcyZxdW90OykuICBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZQoraW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6PC9wPgorCis8dWw+CisgICAgICAgPGxpPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeTwvbGk+CisgICAgICAgPGxpPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzPC9saT4KKyAgICAgICA8bGk+SW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSczwvbGk+CisgICAgICAgPGxpPlN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICZxdW90O3NyYyZxdW90OyBvZiBjZXJ0YWluIFBsdWctaW5zPC9saT4KKyAgICAgICA8bGk+RmVhdHVyZSBkaXJlY3RvcmllczwvbGk+Cis8L3VsPgorCis8cD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IChhcyBkZWZpbmVkIGJlbG93KSwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgmcXVvdDtGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlJnF1b3Q7KSBkdXJpbmcgdGhlCitpbnN0YWxsYXRpb24gcHJvY2Vzcy4gIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zIEluY2x1ZGVkIEZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IKK2luZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgJnF1b3Q7bGljZW5zZSZxdW90OyBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnByb3BlcnRpZXMmcXVvdDsgZm91bmQgd2l0aGluIGEgRmVhdHVyZS4KK1N1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzLCBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbgordGhhdCBkaXJlY3RvcnkuPC9wPgorCis8cD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIFRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiAgU09NRSBPRiBUSEVTRQorT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+RWNsaXBzZSBEaXN0cmlidXRpb24gTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MS4wLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9hPik8L2xpPgorICAgICAgIDxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvYT4pPC9saT4KKyAgICAgICA8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgorPC91bD4KKworPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiBUTyBVU0UgT0YgVEhFIENPTlRFTlQuICBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlLCBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIHByb3ZpZGVkLCBwbGVhc2UKK2NvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgorCisKKzxoMz5Vc2Ugb2YgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3k8L2gzPgorCis8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBwcm92aXNpb25pbmcgc29mdHdhcmUsIGV4YW1wbGVzIG9mIHdoaWNoIGluY2x1ZGUsIGJ1dCBhcmUgbm90IGxpbWl0ZWQgdG8sIHAyIGFuZCB0aGUgRWNsaXBzZQorICAgVXBkYXRlIE1hbmFnZXIgKCZxdW90O1Byb3Zpc2lvbmluZyBUZWNobm9sb2d5JnF1b3Q7KSBmb3IgdGhlIHB1cnBvc2Ugb2YgYWxsb3dpbmcgdXNlcnMgdG8gaW5zdGFsbCBzb2Z0d2FyZSwgZG9jdW1lbnRhdGlvbiwgaW5mb3JtYXRpb24gYW5kL29yCisgICBvdGhlciBtYXRlcmlhbHMgKGNvbGxlY3RpdmVseSAmcXVvdDtJbnN0YWxsYWJsZSBTb2Z0d2FyZSZxdW90OykuIFRoaXMgY2FwYWJpbGl0eSBpcyBwcm92aWRlZCB3aXRoIHRoZSBpbnRlbnQgb2YgYWxsb3dpbmcgc3VjaCB1c2VycyB0bworICAgaW5zdGFsbCwgZXh0ZW5kIGFuZCB1cGRhdGUgRWNsaXBzZS1iYXNlZCBwcm9kdWN0cy4gSW5mb3JtYXRpb24gYWJvdXQgcGFja2FnaW5nIEluc3RhbGxhYmxlIFNvZnR3YXJlIGlzIGF2YWlsYWJsZSBhdCA8YQorICAgICAgIGhyZWY9Imh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWwiPmh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWw8L2E+CisgICAoJnF1b3Q7U3BlY2lmaWNhdGlvbiZxdW90OykuPC9wPgorCis8cD5Zb3UgbWF5IHVzZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSB0byBhbGxvdyBvdGhlciBwYXJ0aWVzIHRvIGluc3RhbGwgSW5zdGFsbGFibGUgU29mdHdhcmUuIFlvdSBzaGFsbCBiZSByZXNwb25zaWJsZSBmb3IgZW5hYmxpbmcgdGhlCisgICBhcHBsaWNhYmxlIGxpY2Vuc2UgYWdyZWVtZW50cyByZWxhdGluZyB0byB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUgdG8gYmUgcHJlc2VudGVkIHRvLCBhbmQgYWNjZXB0ZWQgYnksIHRoZSB1c2VycyBvZiB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kKKyAgIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gQnkgdXNpbmcgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgaW4gc3VjaCBhIG1hbm5lciBhbmQgbWFraW5nIGl0IGF2YWlsYWJsZSBpbiBhY2NvcmRhbmNlIHdpdGggdGhlCisgICBTcGVjaWZpY2F0aW9uLCB5b3UgZnVydGhlciBhY2tub3dsZWRnZSB5b3VyIGFncmVlbWVudCB0bywgYW5kIHRoZSBhY3F1aXNpdGlvbiBvZiBhbGwgbmVjZXNzYXJ5IHJpZ2h0cyB0byBwZXJtaXQgdGhlIGZvbGxvd2luZzo8L3A+CisKKzxvbD4KKyAgICAgICA8bGk+QSBzZXJpZXMgb2YgYWN0aW9ucyBtYXkgb2NjdXIgKCZxdW90O1Byb3Zpc2lvbmluZyBQcm9jZXNzJnF1b3Q7KSBpbiB3aGljaCBhIHVzZXIgbWF5IGV4ZWN1dGUgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5CisgICAgICAgb24gYSBtYWNoaW5lICgmcXVvdDtUYXJnZXQgTWFjaGluZSZxdW90Oykgd2l0aCB0aGUgaW50ZW50IG9mIGluc3RhbGxpbmcsIGV4dGVuZGluZyBvciB1cGRhdGluZyB0aGUgZnVuY3Rpb25hbGl0eSBvZiBhbiBFY2xpcHNlLWJhc2VkCisgICAgICAgcHJvZHVjdC48L2xpPgorICAgICAgIDxsaT5EdXJpbmcgdGhlIFByb3Zpc2lvbmluZyBQcm9jZXNzLCB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgbWF5IGNhdXNlIHRoaXJkIHBhcnR5IEluc3RhbGxhYmxlIFNvZnR3YXJlIG9yIGEgcG9ydGlvbiB0aGVyZW9mIHRvIGJlCisgICAgICAgYWNjZXNzZWQgYW5kIGNvcGllZCB0byB0aGUgVGFyZ2V0IE1hY2hpbmUuPC9saT4KKyAgICAgICA8bGk+UHVyc3VhbnQgdG8gdGhlIFNwZWNpZmljYXRpb24sIHlvdSB3aWxsIHByb3ZpZGUgdG8gdGhlIHVzZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuIHRoZSB1c2Ugb2YgdGhlIEluc3RhbGxhYmxlCisgICAgICAgU29mdHdhcmUgKCZxdW90O0luc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCZxdW90OykgYW5kIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IHNoYWxsIGJlIGFjY2Vzc2VkIGZyb20gdGhlIFRhcmdldAorICAgICAgIE1hY2hpbmUgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBTdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCBtdXN0IGluZm9ybSB0aGUgdXNlciBvZiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdCBnb3Zlcm4KKyAgICAgICB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUgYW5kIG11c3Qgc29saWNpdCBhY2NlcHRhbmNlIGJ5IHRoZSBlbmQgdXNlciBpbiB0aGUgbWFubmVyIHByZXNjcmliZWQgaW4gc3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQuIFVwb24gc3VjaAorICAgICAgIGluZGljYXRpb24gb2YgYWdyZWVtZW50IGJ5IHRoZSB1c2VyLCB0aGUgcHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgd2lsbCBjb21wbGV0ZSBpbnN0YWxsYXRpb24gb2YgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlLjwvbGk+Cis8L29sPgorCis8aDM+Q3J5cHRvZ3JhcGh5PC9oMz4KKworPHA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIGN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIHJlLWV4cG9ydCB0bworICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsCisgICBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvcD4KKworPHA+PHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgT3JhY2xlIENvcnBvcmF0aW9uIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguPC9zbWFsbD48L3A+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlLy5wcm9qZWN0IGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZmVhdHVyZS8ucHJvamVjdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43OGVjMTI4Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZmVhdHVyZS8ucHJvamVjdApAQCAtMCwwICsxLDM0IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPHByb2plY3REZXNjcmlwdGlvbj4KKwk8bmFtZT5vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlPC9uYW1lPgorCTxjb21tZW50PjwvY29tbWVudD4KKwk8cHJvamVjdHM+CisJPC9wcm9qZWN0cz4KKwk8YnVpbGRTcGVjPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuRmVhdHVyZUJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuc29uYXJsaW50LmVjbGlwc2UuY29yZS5zb25hcmxpbnRCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwk8L2J1aWxkU3BlYz4KKwk8bmF0dXJlcz4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQueHRleHROYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5tMmUuY29yZS5tYXZlbjJOYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuRmVhdHVyZU5hdHVyZTwvbmF0dXJlPgorCTwvbmF0dXJlcz4KKzwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZmVhdHVyZS9MSUNFTlNFLnR4dCBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmZlYXR1cmUvTElDRU5TRS50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmY0MmFkNAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmZlYXR1cmUvTElDRU5TRS50eHQKQEAgLTAsMCArMSwxNjEgQEAKK0VjbGlwc2UgUHVibGljIExpY2Vuc2UgLXYgMS4wCisKK1RIRSBBQ0NPTVBBTllJTkcgUFJPR1JBTSBJUyBQUk9WSURFRCBVTkRFUiBUSEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgiQUdSRUVNRU5UIikuIEFOWSBVU0UsIFJFUFJPRFVDVElPTgorT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UgT0YgVEhJUyBBR1JFRU1FTlQuCisKKzEuIERFRklOSVRJT05TCisKKyJDb250cmlidXRpb24iIG1lYW5zOgorCithKSBpbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbiBkaXN0cmlidXRlZCB1bmRlciB0aGlzIEFncmVlbWVudCwgYW5kCisKK2IpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjoKKworaSkgY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kCisKK2lpKSBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07CisKK3doZXJlIHN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQgYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLgorQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvciBpZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lCithY3Rpbmcgb24gc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gd2hpY2g6IChpKSBhcmUgc2VwYXJhdGUKK21vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24gd2l0aCB0aGUgUHJvZ3JhbSB1bmRlciB0aGVpciBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIGFuZCAoaWkpIGFyZSBub3QKK2Rlcml2YXRpdmUgd29ya3Mgb2YgdGhlIFByb2dyYW0uCisKKyJDb250cmlidXRvciIgbWVhbnMgYW55IHBlcnNvbiBvciBlbnRpdHkgdGhhdCBkaXN0cmlidXRlcyB0aGUgUHJvZ3JhbS4KKworIkxpY2Vuc2VkIFBhdGVudHMgIiBtZWFuIHBhdGVudCBjbGFpbXMgbGljZW5zYWJsZSBieSBhIENvbnRyaWJ1dG9yIHdoaWNoIGFyZSBuZWNlc3NhcmlseSBpbmZyaW5nZWQgYnkgdGhlIHVzZSBvciBzYWxlIG9mCitpdHMgQ29udHJpYnV0aW9uIGFsb25lIG9yIHdoZW4gY29tYmluZWQgd2l0aCB0aGUgUHJvZ3JhbS4KKworIlByb2dyYW0iIG1lYW5zIHRoZSBDb250cmlidXRpb25zIGRpc3RyaWJ1dGVkIGluIGFjY29yZGFuY2Ugd2l0aCB0aGlzIEFncmVlbWVudC4KKworIlJlY2lwaWVudCIgbWVhbnMgYW55b25lIHdobyByZWNlaXZlcyB0aGUgUHJvZ3JhbSB1bmRlciB0aGlzIEFncmVlbWVudCwgaW5jbHVkaW5nIGFsbCBDb250cmlidXRvcnMuCisKKzIuIEdSQU5UIE9GIFJJR0hUUworCithKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBjb3B5cmlnaHQgbGljZW5zZSB0byByZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkgZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgZGlzdHJpYnV0ZQorYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGFuZCBzdWNoIGRlcml2YXRpdmUgd29ya3MsIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZQorZm9ybS4KKworYikgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydCBhbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZQorQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlCitjb21iaW5hdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZCBieSB0aGUgQ29udHJpYnV0b3IsIHN1Y2gKK2FkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24gdG8gYmUgY292ZXJlZCBieSB0aGUgTGljZW5zZWQgUGF0ZW50cy4gVGhlIHBhdGVudCBsaWNlbnNlIHNoYWxsIG5vdAorYXBwbHkgdG8gYW55IG90aGVyIGNvbWJpbmF0aW9ucyB3aGljaCBpbmNsdWRlIHRoZSBDb250cmlidXRpb24uIE5vIGhhcmR3YXJlIHBlciBzZSBpcyBsaWNlbnNlZCBoZXJldW5kZXIuCisKK2MpIFJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMgQ29udHJpYnV0aW9ucyBzZXQgZm9ydGggaGVyZWluLCBubworYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yIHRoYXQgdGhlIFByb2dyYW0gZG9lcyBub3QgaW5mcmluZ2UgdGhlIHBhdGVudCBvciBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKK3JpZ2h0cyBvZiBhbnkgb3RoZXIgZW50aXR5LiBFYWNoIENvbnRyaWJ1dG9yIGRpc2NsYWltcyBhbnkgbGlhYmlsaXR5IHRvIFJlY2lwaWVudCBmb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eQorYmFzZWQgb24gaW5mcmluZ2VtZW50IG9mIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCitsaWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eSB0byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQorcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwgaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZSB0aGUKK1Byb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZSBkaXN0cmlidXRpbmcgdGhlIFByb2dyYW0uCisKK2QpIEVhY2ggQ29udHJpYnV0b3IgcmVwcmVzZW50cyB0aGF0IHRvIGl0cyBrbm93bGVkZ2UgaXQgaGFzIHN1ZmZpY2llbnQgY29weXJpZ2h0IHJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvCitncmFudCB0aGUgY29weXJpZ2h0IGxpY2Vuc2Ugc2V0IGZvcnRoIGluIHRoaXMgQWdyZWVtZW50LgorCiszLiBSRVFVSVJFTUVOVFMKKworQSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0OgorCithKSBpdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kCisKK2IpIGl0cyBsaWNlbnNlIGFncmVlbWVudDoKKworaSkgZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZCBjb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcKK3dhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZSBhbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eSBhbmQKK2ZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOworCitpaSkgZWZmZWN0aXZlbHkgZXhjbHVkZXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIGxpYWJpbGl0eSBmb3IgZGFtYWdlcywgaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsCitpbmNpZGVudGFsIGFuZCBjb25zZXF1ZW50aWFsIGRhbWFnZXMsIHN1Y2ggYXMgbG9zdCBwcm9maXRzOworCitpaWkpIHN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQgQ29udHJpYnV0b3IgYWxvbmUgYW5kIG5vdCBieSBhbnkKK290aGVyIHBhcnR5OyBhbmQKKworaXYpIHN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQgaW5mb3JtcyBsaWNlbnNlZXMgaG93IHRvIG9idGFpbiBpdAoraW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEgbWVkaXVtIGN1c3RvbWFyaWx5IHVzZWQgZm9yIHNvZnR3YXJlIGV4Y2hhbmdlLgorCitXaGVuIHRoZSBQcm9ncmFtIGlzIG1hZGUgYXZhaWxhYmxlIGluIHNvdXJjZSBjb2RlIGZvcm06CisKK2EpIGl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZAorCitiKSBhIGNvcHkgb2YgdGhpcyBBZ3JlZW1lbnQgbXVzdCBiZSBpbmNsdWRlZCB3aXRoIGVhY2ggY29weSBvZiB0aGUgUHJvZ3JhbS4KKworQ29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueSBjb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLgorCitFYWNoIENvbnRyaWJ1dG9yIG11c3QgaWRlbnRpZnkgaXRzZWxmIGFzIHRoZSBvcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cworc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uCisKKzQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OCisKK0NvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heSBhY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzIGFuZAordGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZSBvZiB0aGUgUHJvZ3JhbSwgdGhlIENvbnRyaWJ1dG9yIHdobyBpbmNsdWRlcwordGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcgc2hvdWxkIGRvIHNvIGluIGEgbWFubmVyIHdoaWNoIGRvZXMgbm90IGNyZWF0ZSBwb3RlbnRpYWwgbGlhYmlsaXR5IGZvcgorb3RoZXIgQ29udHJpYnV0b3JzLiBUaGVyZWZvcmUsIGlmIGEgQ29udHJpYnV0b3IgaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IKKygiQ29tbWVyY2lhbCBDb250cmlidXRvciIpIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIgQ29udHJpYnV0b3IgKCJJbmRlbW5pZmllZCBDb250cmlidXRvciIpCithZ2FpbnN0IGFueSBsb3NzZXMsIGRhbWFnZXMgYW5kIGNvc3RzIChjb2xsZWN0aXZlbHkgIkxvc3NlcyIpIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlciBsZWdhbCBhY3Rpb25zCiticm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8gdGhlIGV4dGVudCBjYXVzZWQgYnkgdGhlIGFjdHMgb3Igb21pc3Npb25zIG9mIHN1Y2gKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4gY29ubmVjdGlvbiB3aXRoIGl0cyBkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcuIFRoZQorb2JsaWdhdGlvbnMgaW4gdGhpcyBzZWN0aW9uIGRvIG5vdCBhcHBseSB0byBhbnkgY2xhaW1zIG9yIExvc3NlcyByZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsCitwcm9wZXJ0eSBpbmZyaW5nZW1lbnQuIEluIG9yZGVyIHRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAorQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZQorQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kIGFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5CisgcGFydGljaXBhdGUgaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLgorCitGb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBQcm9kdWN0IFguIFRoYXQgQ29udHJpYnV0b3IgaXMKK3RoZW4gYSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yLiBJZiB0aGF0IENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdGhlbiBtYWtlcyBwZXJmb3JtYW5jZSBjbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzCityZWxhdGVkIHRvIFByb2R1Y3QgWCwgdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4KK1VuZGVyIHRoaXMgc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlIG90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvCit0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhIGNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsCit0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLgorCis1LiBOTyBXQVJSQU5UWQorCitFWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTIEFHUkVFTUVOVCwgVEhFIFBST0dSQU0gSVMgUFJPVklERUQgT04gQU4gIkFTIElTIiBCQVNJUywgV0lUSE9VVCBXQVJSQU5USUVTIE9SCitDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywgV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLAorTk9OLUlORlJJTkdFTUVOVCwgTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkgcmVzcG9uc2libGUgZm9yCitkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlIFByb2dyYW0gYW5kIGFzc3VtZXMgYWxsIHJpc2tzIGFzc29jaWF0ZWQgd2l0aCBpdHMKK2V4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCAsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIHJpc2tzIGFuZCBjb3N0cyBvZiBwcm9ncmFtIGVycm9ycywgY29tcGxpYW5jZQord2l0aCBhcHBsaWNhYmxlIGxhd3MsIGRhbWFnZSB0byBvciBsb3NzIG9mIGRhdGEsIHByb2dyYW1zIG9yIGVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLgorCis2LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWQorCitFWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTIEFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUiBBTlkKK0RJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcgV0lUSE9VVCBMSU1JVEFUSU9OIExPU1QgUFJPRklUUyksCitIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SCitPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRAorSEVSRVVOREVSLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy4KKworNy4gR0VORVJBTAorCitJZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQgb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKK2VuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dCBmdXJ0aGVyIGFjdGlvbiBieSB0aGUgcGFydGllcyBoZXJldG8sIHN1Y2gKK3Byb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUgbWluaW11bSBleHRlbnQgbmVjZXNzYXJ5IHRvIG1ha2Ugc3VjaCBwcm92aXNpb24gdmFsaWQgYW5kIGVuZm9yY2VhYmxlLgorCitJZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbiBhZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCithbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoIG90aGVyIHNvZnR3YXJlIG9yIGhhcmR3YXJlKSBpbmZyaW5nZXMgc3VjaAorUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2ggUmVjaXBpZW50J3MgcmlnaHRzIGdyYW50ZWQgdW5kZXIgU2VjdGlvbiAyKGIpIHNoYWxsIHRlcm1pbmF0ZSBhcyBvZiB0aGUgZGF0ZSBzdWNoCitsaXRpZ2F0aW9uIGlzIGZpbGVkLgorCitBbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCitjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUgcGVyaW9kIG9mIHRpbWUgYWZ0ZXIgYmVjb21pbmcgYXdhcmUgb2Ygc3VjaAorbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCB0ZXJtaW5hdGUsIFJlY2lwaWVudCBhZ3JlZXMgdG8gY2Vhc2UgdXNlIGFuZCBkaXN0cmlidXRpb24KK29mIHRoZSBQcm9ncmFtIGFzIHNvb24gYXMgcmVhc29uYWJseSBwcmFjdGljYWJsZS4gSG93ZXZlciwgUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcworIGdyYW50ZWQgYnkgUmVjaXBpZW50IHJlbGF0aW5nIHRvIHRoZSBQcm9ncmFtIHNoYWxsIGNvbnRpbnVlIGFuZCBzdXJ2aXZlLgorCitFdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZSBjb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQKK2lzIGNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudCBTdGV3YXJkIHJlc2VydmVzIHRoZSByaWdodCB0byBwdWJsaXNoCituZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mIHRoaXMgQWdyZWVtZW50IGZyb20gdGltZSB0byB0aW1lLiBObyBvbmUgb3RoZXIgdGhhbiB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgaGFzIHRoZQorcmlnaHQgdG8gbW9kaWZ5IHRoaXMgQWdyZWVtZW50LiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHRoZSBpbml0aWFsIEFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heQorYXNzaWduIHRoZSByZXNwb25zaWJpbGl0eSB0byBzZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24gb2YgdGhlCitBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbSAoaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUKK2Rpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YgdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCit0aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0gKGluY2x1ZGluZyBpdHMgQ29udHJpYnV0aW9ucykgdW5kZXIgdGhlCituZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQgaW4gU2VjdGlvbnMgMihhKSBhbmQgMihiKSBhYm92ZSwgUmVjaXBpZW50IHJlY2VpdmVzIG5vIHJpZ2h0cyBvciBsaWNlbnNlcyB0bwordGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBvZiBhbnkgQ29udHJpYnV0b3IgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIHdoZXRoZXIgZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3IKK290aGVyd2lzZS4gQWxsIHJpZ2h0cyBpbiB0aGUgUHJvZ3JhbSBub3QgZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLgorCitUaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUgU3RhdGUgb2YgTmV3IFlvcmsgYW5kIHRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgbGF3cyBvZiB0aGUgVW5pdGVkIFN0YXRlcworb2YgQW1lcmljYS4gTm8gcGFydHkgdG8gdGhpcyBBZ3JlZW1lbnQgd2lsbCBicmluZyBhIGxlZ2FsIGFjdGlvbiB1bmRlciB0aGlzIEFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlCitvZiBhY3Rpb24gYXJvc2UuIEVhY2ggcGFydHkgd2FpdmVzIGl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlL2J1aWxkLnByb3BlcnRpZXMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGQxZGIyMAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmZlYXR1cmUvYnVpbGQucHJvcGVydGllcwpAQCAtMCwwICsxLDUgQEAKK2Jpbi5pbmNsdWRlcyA9IGVwbC12MTAuaHRtbCwgIGZlYXR1cmUueG1sLFwKKyAgICAgICAgICAgICAgIGZlYXR1cmUucHJvcGVydGllcyxcCisgICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKK3NyYy5pbmNsdWRlcyA9IGVwbC12MTAuaHRtbCwgIExJQ0VOU0UudHh0LFwKKyAgICAgICAgICAgICAgIGxpY2Vuc2UuaHRtbApkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZmVhdHVyZS9lcGwtdjEwLmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlL2VwbC12MTAuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iMzk4YWNjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZmVhdHVyZS9lcGwtdjEwLmh0bWwKQEAgLTAsMCArMSwyNTkgQEAKKzwhLS0/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IklTTy04ODU5LTEiID8tLT4KKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFRyYW5zaXRpb25hbC8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS10cmFuc2l0aW9uYWwuZHRkIj4KKzxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIj48aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgorPHRpdGxlPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSBWZXJzaW9uIDEuMDwvdGl0bGU+Cis8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgorICBib2R5IHsKKyAgICBzaXplOiA4LjVpbiAxMS4waW47CisgICAgbWFyZ2luOiAwLjI1aW4gMC41aW4gMC4yNWluIDAuNWluOworICAgIHRhYi1pbnRlcnZhbDogMC41aW47CisgICAgfQorICBwIHsgIAkKKyAgICBtYXJnaW4tbGVmdDogYXV0bzsKKyAgICBtYXJnaW4tdG9wOiAgMC41ZW07CisgICAgbWFyZ2luLWJvdHRvbTogMC41ZW07CisgICAgfQorICBwLmxpc3QgeworICAJbWFyZ2luLWxlZnQ6IDAuNWluOworICAgIG1hcmdpbi10b3A6ICAwLjA1ZW07CisgICAgbWFyZ2luLWJvdHRvbTogMC4wNWVtOworICAgIH0KKyAgPC9zdHlsZT4KKworPC9oZWFkPgorCis8Ym9keSBsYW5nPSJFTi1VUyI+CisKKzxoMj5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gdiAxLjA8L2gyPgorCis8cD5USEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIgVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRQorUFVCTElDIExJQ0VOU0UgKCJBR1JFRU1FTlQiKS4gQU5ZIFVTRSwgUkVQUk9EVUNUSU9OIE9SCitESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRSBPRiBUSElTCitBR1JFRU1FTlQuPC9wPgorCis8cD48Yj4xLiBERUZJTklUSU9OUzwvYj48L3A+CisKKzxwPiJDb250cmlidXRpb24iIG1lYW5zOjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmEpIGluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbAorY29kZSBhbmQgZG9jdW1lbnRhdGlvbiBkaXN0cmlidXRlZCB1bmRlciB0aGlzIEFncmVlbWVudCwgYW5kPC9wPgorPHAgY2xhc3M9Imxpc3QiPmIpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjo8L3A+Cis8cCBjbGFzcz0ibGlzdCI+aSkgY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kPC9wPgorPHAgY2xhc3M9Imxpc3QiPmlpKSBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07PC9wPgorPHAgY2xhc3M9Imxpc3QiPndoZXJlIHN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtCitvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkIGJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4gQQorQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IgaWYgaXQgd2FzIGFkZGVkIHRvIHRoZQorUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUgYWN0aW5nIG9uIHN1Y2gKK0NvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUKK1Byb2dyYW0gd2hpY2g6IChpKSBhcmUgc2VwYXJhdGUgbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbgorY29uanVuY3Rpb24gd2l0aCB0aGUgUHJvZ3JhbSB1bmRlciB0aGVpciBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIGFuZCAoaWkpCithcmUgbm90IGRlcml2YXRpdmUgd29ya3Mgb2YgdGhlIFByb2dyYW0uPC9wPgorCis8cD4iQ29udHJpYnV0b3IiIG1lYW5zIGFueSBwZXJzb24gb3IgZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMKK3RoZSBQcm9ncmFtLjwvcD4KKworPHA+IkxpY2Vuc2VkIFBhdGVudHMiIG1lYW4gcGF0ZW50IGNsYWltcyBsaWNlbnNhYmxlIGJ5IGEKK0NvbnRyaWJ1dG9yIHdoaWNoIGFyZSBuZWNlc3NhcmlseSBpbmZyaW5nZWQgYnkgdGhlIHVzZSBvciBzYWxlIG9mIGl0cworQ29udHJpYnV0aW9uIGFsb25lIG9yIHdoZW4gY29tYmluZWQgd2l0aCB0aGUgUHJvZ3JhbS48L3A+CisKKzxwPiJQcm9ncmFtIiBtZWFucyB0aGUgQ29udHJpYnV0aW9ucyBkaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlCit3aXRoIHRoaXMgQWdyZWVtZW50LjwvcD4KKworPHA+IlJlY2lwaWVudCIgbWVhbnMgYW55b25lIHdobyByZWNlaXZlcyB0aGUgUHJvZ3JhbSB1bmRlcgordGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLjwvcD4KKworPHA+PGI+Mi4gR1JBTlQgT0YgUklHSFRTPC9iPjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmEpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoCitDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBjb3B5cmlnaHQgbGljZW5zZSB0byByZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3Jrcworb2YsIHB1YmxpY2x5IGRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUgYW5kIHN1YmxpY2Vuc2UgdGhlCitDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbgorc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YikgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2gKK0NvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIHBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLAorb2ZmZXIgdG8gc2VsbCwgaW1wb3J0IGFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoCitDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQKK2xpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlIGNvbWJpbmF0aW9uIG9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZQorUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZCBieSB0aGUgQ29udHJpYnV0b3IsCitzdWNoIGFkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24gdG8gYmUgY292ZXJlZAorYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QgYXBwbHkgdG8gYW55IG90aGVyCitjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMKK2xpY2Vuc2VkIGhlcmV1bmRlci48L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5jKSBSZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yCitncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cyBDb250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vIGFzc3VyYW5jZXMKK2FyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IgdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUKK3BhdGVudCBvciBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2gKK0NvbnRyaWJ1dG9yIGRpc2NsYWltcyBhbnkgbGlhYmlsaXR5IHRvIFJlY2lwaWVudCBmb3IgY2xhaW1zIGJyb3VnaHQgYnkKK2FueSBvdGhlciBlbnRpdHkgYmFzZWQgb24gaW5mcmluZ2VtZW50IG9mIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMKK29yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZCBsaWNlbnNlcworZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkgdG8KK3NlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yCitleGFtcGxlLCBpZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudAordG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZQordGhhdCBsaWNlbnNlIGJlZm9yZSBkaXN0cmlidXRpbmcgdGhlIFByb2dyYW0uPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+ZCkgRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdAoraGFzIHN1ZmZpY2llbnQgY29weXJpZ2h0IHJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvIGdyYW50Cit0aGUgY29weXJpZ2h0IGxpY2Vuc2Ugc2V0IGZvcnRoIGluIHRoaXMgQWdyZWVtZW50LjwvcD4KKworPHA+PGI+My4gUkVRVUlSRU1FTlRTPC9iPjwvcD4KKworPHA+QSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0gaW4gb2JqZWN0IGNvZGUKK2Zvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDo8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5hKSBpdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzCitBZ3JlZW1lbnQ7IGFuZDwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmIpIGl0cyBsaWNlbnNlIGFncmVlbWVudDo8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5pKSBlZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMKK2FsbCB3YXJyYW50aWVzIGFuZCBjb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcgd2FycmFudGllcworb3IgY29uZGl0aW9ucyBvZiB0aXRsZSBhbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvcgorY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkgYW5kIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOzwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmlpKSBlZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycworYWxsIGxpYWJpbGl0eSBmb3IgZGFtYWdlcywgaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsCitpbmNpZGVudGFsIGFuZCBjb25zZXF1ZW50aWFsIGRhbWFnZXMsIHN1Y2ggYXMgbG9zdCBwcm9maXRzOzwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmlpaSkgc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcworQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQgQ29udHJpYnV0b3IgYWxvbmUgYW5kIG5vdCBieSBhbnkgb3RoZXIKK3BhcnR5OyBhbmQ8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5pdikgc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZQorZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQgaW5mb3JtcyBsaWNlbnNlZXMgaG93IHRvIG9idGFpbiBpdCBpbiBhCityZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEgbWVkaXVtIGN1c3RvbWFyaWx5IHVzZWQgZm9yIHNvZnR3YXJlCitleGNoYW5nZS48L3A+CisKKzxwPldoZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlIGNvZGUgZm9ybTo8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5hKSBpdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQ8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5iKSBhIGNvcHkgb2YgdGhpcyBBZ3JlZW1lbnQgbXVzdCBiZSBpbmNsdWRlZCB3aXRoIGVhY2gKK2NvcHkgb2YgdGhlIFByb2dyYW0uPC9wPgorCis8cD5Db250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55IGNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZAord2l0aGluIHRoZSBQcm9ncmFtLjwvcD4KKworPHA+RWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUgb3JpZ2luYXRvciBvZiBpdHMKK0NvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzIHN1YnNlcXVlbnQKK1JlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi48L3A+CisKKzxwPjxiPjQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OPC9iPjwvcD4KKworPHA+Q29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5IGFjY2VwdCBjZXJ0YWluCityZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzIGFuZCB0aGUKK2xpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZSBvZgordGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsCitwcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUKK3BvdGVudGlhbCBsaWFiaWxpdHkgZm9yIG90aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yCitpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvcgorKCJDb21tZXJjaWFsIENvbnRyaWJ1dG9yIikgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kCitpbmRlbW5pZnkgZXZlcnkgb3RoZXIgQ29udHJpYnV0b3IgKCJJbmRlbW5pZmllZCBDb250cmlidXRvciIpCithZ2FpbnN0IGFueSBsb3NzZXMsIGRhbWFnZXMgYW5kIGNvc3RzIChjb2xsZWN0aXZlbHkgIkxvc3NlcyIpCithcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIgbGVnYWwgYWN0aW9ucyBicm91Z2h0IGJ5IGEgdGhpcmQKK3BhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvIHRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZQorYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluIGNvbm5lY3Rpb24gd2l0aCBpdHMKK2Rpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZy4gVGhlCitvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzCityZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGluZnJpbmdlbWVudC4gSW4KK29yZGVyIHRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeQordGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUgQ29tbWVyY2lhbAorQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZCBhbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlCitJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkgcGFydGljaXBhdGUgaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93bgorZXhwZW5zZS48L3A+CisKKzxwPkZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsCitwcm9kdWN0IG9mZmVyaW5nLCBQcm9kdWN0IFguIFRoYXQgQ29udHJpYnV0b3IgaXMgdGhlbiBhIENvbW1lcmNpYWwKK0NvbnRyaWJ1dG9yLiBJZiB0aGF0IENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdGhlbiBtYWtlcyBwZXJmb3JtYW5jZQorY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcyByZWxhdGVkIHRvIFByb2R1Y3QgWCwgdGhvc2UgcGVyZm9ybWFuY2UKK2NsYWltcyBhbmQgd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkKK2Fsb25lLiBVbmRlciB0aGlzIHNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8KK2RlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUgb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8gdGhvc2UKK3BlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEgY291cnQgcmVxdWlyZXMgYW55IG90aGVyCitDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yCittdXN0IHBheSB0aG9zZSBkYW1hZ2VzLjwvcD4KKworPHA+PGI+NS4gTk8gV0FSUkFOVFk8L2I+PC9wPgorCis8cD5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTIEFHUkVFTUVOVCwgVEhFIFBST0dSQU0gSVMKK1BST1ZJREVEIE9OIEFOICJBUyBJUyIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TCitPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsIFdJVEhPVVQgTElNSVRBVElPTiwKK0FOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsIE5PTi1JTkZSSU5HRU1FTlQsIE1FUkNIQU5UQUJJTElUWQorT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseQorcmVzcG9uc2libGUgZm9yIGRldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kCitkaXN0cmlidXRpbmcgdGhlIFByb2dyYW0gYW5kIGFzc3VtZXMgYWxsIHJpc2tzIGFzc29jaWF0ZWQgd2l0aCBpdHMKK2V4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCAsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8KK3RoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsIGNvbXBsaWFuY2Ugd2l0aCBhcHBsaWNhYmxlIGxhd3MsCitkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvciBlcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvcgoraW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuPC9wPgorCis8cD48Yj42LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWTwvYj48L3A+CisKKzxwPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVAorTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwKK0lOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcKK1dJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLCBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRgorTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcKK05FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IKK0RJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVECitIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLjwvcD4KKworPHA+PGI+Ny4gR0VORVJBTDwvYj48L3A+CisKKzxwPklmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZCBvciB1bmVuZm9yY2VhYmxlIHVuZGVyCithcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IgZW5mb3JjZWFiaWxpdHkgb2YKK3RoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dCBmdXJ0aGVyIGFjdGlvbgorYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoIHByb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUgbWluaW11bQorZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS48L3A+CisKKzxwPklmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uIGFnYWluc3QgYW55IGVudGl0eQorKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpIGFsbGVnaW5nIHRoYXQgdGhlCitQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoIG90aGVyCitzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2ggUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2gKK1JlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlCitkYXRlIHN1Y2ggbGl0aWdhdGlvbiBpcyBmaWxlZC48L3A+CisKKzxwPkFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgc2hhbGwgdGVybWluYXRlIGlmIGl0CitmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yIGNvbmRpdGlvbnMgb2YgdGhpcworQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUgcGVyaW9kIG9mIHRpbWUKK2FmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2ggbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzIHJpZ2h0cwordW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQKK2Rpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsCitSZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzIGdyYW50ZWQgYnkKK1JlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS48L3A+CisKKzxwPkV2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlIGNvcGllcyBvZiB0aGlzCitBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQgaXMKK2NvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlCitBZ3JlZW1lbnQgU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaCBuZXcgdmVyc2lvbnMgKGluY2x1ZGluZworcmV2aXNpb25zKSBvZiB0aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlCitBZ3JlZW1lbnQgU3Rld2FyZCBoYXMgdGhlIHJpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UKK0ZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwgQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5Cithc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvIHNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhCitzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24gb2YgdGhlIEFncmVlbWVudCB3aWxsIGJlCitnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbSAoaW5jbHVkaW5nCitDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlIGRpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YgdGhlCitBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbgorb2YgdGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZQorUHJvZ3JhbSAoaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUgbmV3IHZlcnNpb24uIEV4Y2VwdCBhcworZXhwcmVzc2x5IHN0YXRlZCBpbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8KK3JpZ2h0cyBvciBsaWNlbnNlcyB0byB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlcgordGhpcyBBZ3JlZW1lbnQsIHdoZXRoZXIgZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3IKK290aGVyd2lzZS4gQWxsIHJpZ2h0cyBpbiB0aGUgUHJvZ3JhbSBub3QgZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcworQWdyZWVtZW50IGFyZSByZXNlcnZlZC48L3A+CisKKzxwPlRoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZSBTdGF0ZSBvZiBOZXcgWW9yayBhbmQKK3RoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgbGF3cyBvZiB0aGUgVW5pdGVkIFN0YXRlcyBvZiBBbWVyaWNhLiBObyBwYXJ0eQordG8gdGhpcyBBZ3JlZW1lbnQgd2lsbCBicmluZyBhIGxlZ2FsIGFjdGlvbiB1bmRlciB0aGlzIEFncmVlbWVudCBtb3JlCit0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZSBvZiBhY3Rpb24gYXJvc2UuIEVhY2ggcGFydHkgd2FpdmVzIGl0cworcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uPC9wPgorCisKKworPC9ib2R5PjwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmZlYXR1cmUvZmVhdHVyZS5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmU2YjRjOGIKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlL2ZlYXR1cmUucHJvcGVydGllcwpAQCAtMCwwICsxLDE2OSBAQAorIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIworIyBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KS4KKyMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyMKKyMgQ29udHJpYnV0b3JzOgorIyAgICAgQ3Jpc3RpYW5vIEdhdmnjbyAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgorIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIworIyBmZWF0dXJlLnByb3BlcnRpZXMKKyMgY29udGFpbnMgZXh0ZXJuYWxpemVkIHN0cmluZ3MgZm9yIGZlYXR1cmUueG1sCisjICIlZm9vIiBpbiBmZWF0dXJlLnhtbCBjb3JyZXNwb25kcyB0byB0aGUga2V5ICJmb28iIGluIHRoaXMgZmlsZQorIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQorIyBUaGlzIGZpbGUgc2hvdWxkIGJlIHRyYW5zbGF0ZWQuCisKKyMgImZlYXR1cmVOYW1lIiBwcm9wZXJ0eSAtIG5hbWUgb2YgdGhlIGZlYXR1cmUKK2ZlYXR1cmVOYW1lID1PU0JQIFVJIEFQSSAKKworIyAicHJvdmlkZXJOYW1lIiBwcm9wZXJ0eSAtIG5hbWUgb2YgdGhlIGNvbXBhbnkgdGhhdCBwcm92aWRlcyB0aGUgZmVhdHVyZQorcHJvdmlkZXJOYW1lPUVjbGlwc2UgT1NCUAorCisjICJkZXNjcmlwdGlvbiIgcHJvcGVydHkgLSBkZXNjcmlwdGlvbiBvZiB0aGUgZmVhdHVyZQorZGVzY3JpcHRpb249VGhpcyBmZWF0dXJlIHByb3ZpZGVzIHRoZSBidW5kbGVzIGZvciBPU0JQIFVJIEFQSS4KKworIyAidXBkYXRlU2l0ZU5hbWUiIHByb3BlcnR5IC0gbGFiZWwgZm9yIHRoZSB1cGRhdGUgc2l0ZQordXBkYXRlU2l0ZU5hbWU9CisKKyMgImNvcHlyaWdodCIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgQ29weXJpZ2h0IgorY29weXJpZ2h0PVwKK0NvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIFxuXAorQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFsc1xuXAorYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wXG5cCit3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdFxuXAoraHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWxcblwKK1xuXAorIyMjIyMjIyMjIyMjIyMjIyBlbmQgb2YgY29weXJpZ2h0IHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIworCisjICJsaWNlbnNlVVJMIiBwcm9wZXJ0eSAtIFVSTCBvZiB0aGUgIkZlYXR1cmUgTGljZW5zZSIKKyMgZG8gbm90IHRyYW5zbGF0ZSB2YWx1ZSAtIGp1c3QgY2hhbmdlIHRvIHBvaW50IHRvIGEgbG9jYWxlLXNwZWNpZmljIEhUTUwgcGFnZQorbGljZW5zZVVSTD1saWNlbnNlLmh0bWwKKworIyAibGljZW5zZSIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgTGljZW5zZSIKKyMgc2hvdWxkIGJlIHBsYWluIHRleHQgdmVyc2lvbiBvZiBsaWNlbnNlIGFncmVlbWVudCBwb2ludGVkIHRvIGJlICJsaWNlbnNlVVJMIgorbGljZW5zZT1cCitFY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnRcblwKK0ZlYnJ1YXJ5IDEsIDIwMTFcblwKK1xuXAorVXNhZ2UgT2YgQ29udGVudFxuXAorXG5cCitUSEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SXG5cCitPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS5cblwKK1VTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJU1xuXAorQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SXG5cCitOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAorQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAorQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKK09SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRVxuXAorVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OU1xuXAorT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRURcblwKK0JFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC5cblwKK1xuXAorQXBwbGljYWJsZSBMaWNlbnNlc1xuXAorXG5cCitVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlXG5cCitFY2xpcHNlIEZvdW5kYXRpb24gaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZlxuXAordGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXNcblwKK3Byb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC5cblwKK0ZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LlxuXAorXG5cCitDb250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSxcblwKK2RvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBzb3VyY2UgY29kZVxuXAorcmVwb3NpdG9yeSAoIlJlcG9zaXRvcnkiKSBpbiBzb2Z0d2FyZSBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAorYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCitcblwKKyAgICAgICAtIENvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsXG5cCisgICAgICAgICBleHRlbmRpbmcsIGFuZCB1cGdyYWRpbmcgdGhlIENvbnRlbnQuIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoIlBsdWctaW5zIiksXG5cCisgICAgICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAorICAgICAgIC0gRWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhKFRNKSBBUmNoaXZlKVxuXAorICAgICAgICAgaW4gYSBkaXJlY3RvcnkgbmFtZWQgInBsdWdpbnMiLlxuXAorICAgICAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCisgICAgICAgICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAiZmVhdHVyZXMiLlxuXAorICAgICAgICAgV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uXG5cCisgICAgICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCisgICAgICAgLSBGZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXNcblwKKyAgICAgICAgIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIEZlYXR1cmVzLlxuXAorXG5cCitUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlXG5cCitjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImFib3V0Lmh0bWwiICgiQWJvdXRzIikuIFRoZSB0ZXJtcyBhbmRcblwKK2NvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZCBJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkXG5cCitpbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAoIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlXG5cCitMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlXG5cCitpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczpcblwKK1xuXAorICAgICAgIC0gVGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5XG5cCisgICAgICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAorICAgICAgIC0gSW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSc1xuXAorICAgICAgIC0gU3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWluc1xuXAorICAgICAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAorXG5cCitOb3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCitQcm92aXNpb25pbmcgVGVjaG5vbG9neSAoYXMgZGVmaW5lZCBiZWxvdyksIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoIkZlYXR1cmUgXG5cCitVcGRhdGUgTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCitJbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAord2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKK3lvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKK3RoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIgZm91bmQgd2l0aGluIGEgRmVhdHVyZS5cblwKK1N1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzLCBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGVcblwKK3Rlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXRcblwKK2dvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAorXG5cCitUSEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSXG5cCitUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy5cblwKK1NPTUUgT0YgVEhFU0UgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTpcblwKK1xuXAorICAgICAgIC0gRWNsaXBzZSBEaXN0cmlidXRpb24gTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxLjAuaHRtbClcblwKKyAgICAgICAtIENvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sKVxuXAorICAgICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UpXG5cCisgICAgICAgLSBBcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjApXG5cCisgICAgICAgLSBNZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbClcblwKKyAgICAgICAtIE1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwpXG5cCitcblwKK0lUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKK1RPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSwgb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZVxuXAoraXMgcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnNcblwKK2dvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC5cblwKK1xuXAorXG5cVXNlIG9mIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5XG5cCitcblwKK1RoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIHByb3Zpc2lvbmluZyBzb2Z0d2FyZSwgZXhhbXBsZXMgb2Ygd2hpY2ggaW5jbHVkZSxcblwKK2J1dCBhcmUgbm90IGxpbWl0ZWQgdG8sIHAyIGFuZCB0aGUgRWNsaXBzZSBVcGRhdGUgTWFuYWdlciAoIlByb3Zpc2lvbmluZyBUZWNobm9sb2d5IikgZm9yXG5cCit0aGUgcHVycG9zZSBvZiBhbGxvd2luZyB1c2VycyB0byBpbnN0YWxsIHNvZnR3YXJlLCBkb2N1bWVudGF0aW9uLCBpbmZvcm1hdGlvbiBhbmQvb3JcblwKK290aGVyIG1hdGVyaWFscyAoY29sbGVjdGl2ZWx5ICJJbnN0YWxsYWJsZSBTb2Z0d2FyZSIpLiBUaGlzIGNhcGFiaWxpdHkgaXMgcHJvdmlkZWQgd2l0aFxuXAordGhlIGludGVudCBvZiBhbGxvd2luZyBzdWNoIHVzZXJzIHRvIGluc3RhbGwsIGV4dGVuZCBhbmQgdXBkYXRlIEVjbGlwc2UtYmFzZWQgcHJvZHVjdHMuXG5cCitJbmZvcm1hdGlvbiBhYm91dCBwYWNrYWdpbmcgSW5zdGFsbGFibGUgU29mdHdhcmUgaXMgYXZhaWxhYmxlIGF0XG5cCitodHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sICgiU3BlY2lmaWNhdGlvbiIpLlxuXAorXG5cCitZb3UgbWF5IHVzZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSB0byBhbGxvdyBvdGhlciBwYXJ0aWVzIHRvIGluc3RhbGwgSW5zdGFsbGFibGUgU29mdHdhcmUuXG5cCitZb3Ugc2hhbGwgYmUgcmVzcG9uc2libGUgZm9yIGVuYWJsaW5nIHRoZSBhcHBsaWNhYmxlIGxpY2Vuc2UgYWdyZWVtZW50cyByZWxhdGluZyB0byB0aGVcblwKK0luc3RhbGxhYmxlIFNvZnR3YXJlIHRvIGJlIHByZXNlbnRlZCB0bywgYW5kIGFjY2VwdGVkIGJ5LCB0aGUgdXNlcnMgb2YgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5XG5cCitpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIEJ5IHVzaW5nIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IGluIHN1Y2ggYSBtYW5uZXIgYW5kXG5cCittYWtpbmcgaXQgYXZhaWxhYmxlIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbiwgeW91IGZ1cnRoZXIgYWNrbm93bGVkZ2UgeW91clxuXAorYWdyZWVtZW50IHRvLCBhbmQgdGhlIGFjcXVpc2l0aW9uIG9mIGFsbCBuZWNlc3NhcnkgcmlnaHRzIHRvIHBlcm1pdCB0aGUgZm9sbG93aW5nOlxuXAorXG5cCisgICAgICAgMS4gQSBzZXJpZXMgb2YgYWN0aW9ucyBtYXkgb2NjdXIgKCJQcm92aXNpb25pbmcgUHJvY2VzcyIpIGluIHdoaWNoIGEgdXNlciBtYXkgZXhlY3V0ZVxuXAorICAgICAgICAgIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBvbiBhIG1hY2hpbmUgKCJUYXJnZXQgTWFjaGluZSIpIHdpdGggdGhlIGludGVudCBvZiBpbnN0YWxsaW5nLFxuXAorICAgICAgICAgIGV4dGVuZGluZyBvciB1cGRhdGluZyB0aGUgZnVuY3Rpb25hbGl0eSBvZiBhbiBFY2xpcHNlLWJhc2VkIHByb2R1Y3QuXG5cCisgICAgICAgMi4gRHVyaW5nIHRoZSBQcm92aXNpb25pbmcgUHJvY2VzcywgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IG1heSBjYXVzZSB0aGlyZCBwYXJ0eVxuXAorICAgICAgICAgIEluc3RhbGxhYmxlIFNvZnR3YXJlIG9yIGEgcG9ydGlvbiB0aGVyZW9mIHRvIGJlIGFjY2Vzc2VkIGFuZCBjb3BpZWQgdG8gdGhlIFRhcmdldCBNYWNoaW5lLlxuXAorICAgICAgIDMuIFB1cnN1YW50IHRvIHRoZSBTcGVjaWZpY2F0aW9uLCB5b3Ugd2lsbCBwcm92aWRlIHRvIHRoZSB1c2VyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0XG5cCisgICAgICAgICAgZ292ZXJuIHRoZSB1c2Ugb2YgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlICgiSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IikgYW5kIHN1Y2hcblwKKyAgICAgICAgICBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQgc2hhbGwgYmUgYWNjZXNzZWQgZnJvbSB0aGUgVGFyZ2V0IE1hY2hpbmUgaW4gYWNjb3JkYW5jZVxuXAorICAgICAgICAgIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIFN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IG11c3QgaW5mb3JtIHRoZSB1c2VyIG9mIHRoZVxuXAorICAgICAgICAgIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBhbmQgbXVzdCBzb2xpY2l0IGFjY2VwdGFuY2UgYnlcblwKKyAgICAgICAgICB0aGUgZW5kIHVzZXIgaW4gdGhlIG1hbm5lciBwcmVzY3JpYmVkIGluIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50LiBVcG9uIHN1Y2hcblwKKyAgICAgICAgICBpbmRpY2F0aW9uIG9mIGFncmVlbWVudCBieSB0aGUgdXNlciwgdGhlIHByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHdpbGwgY29tcGxldGUgaW5zdGFsbGF0aW9uXG5cCisgICAgICAgICAgb2YgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlLlxuXAorXG5cCitDcnlwdG9ncmFwaHlcblwKK1xuXAorQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCitjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCithbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCit1c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKK3JlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSwgYW5kXG5cCityZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAorXG5cCitKYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIE9yYWNsZSBDb3Jwb3JhdGlvbiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLlxuCisjIyMjIyMjIyMjIyBlbmQgb2YgbGljZW5zZSBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmZlYXR1cmUvZmVhdHVyZS54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlL2ZlYXR1cmUueG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU4NjZjZjYKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlL2ZlYXR1cmUueG1sCkBAIC0wLDAgKzEsMzggQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorPCEtLSMgQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkgLS0+Cis8IS0tIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIC0tPgorPCEtLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIC0tPgorPCEtLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgLS0+Cis8IS0tIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAtLT4KKzwhLS0jIC0tPgorPCEtLSMgQ29udHJpYnV0b3JzOiAtLT4KKzwhLS0jICAgICBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiAtLT4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+CisKKzxmZWF0dXJlCisgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlIgorICAgICAgICBsYWJlbD0iJWZlYXR1cmVOYW1lIgorICAgICAgICB2ZXJzaW9uPSIwLjkuMC5xdWFsaWZpZXIiCisgICAgICAgIHByb3ZpZGVyLW5hbWU9IiVwcm92aWRlck5hbWUiPgorICAgICAgICAKKyAgICA8ZGVzY3JpcHRpb24+CisgICAgICAgICVkZXNjcmlwdGlvbgorICAgIDwvZGVzY3JpcHRpb24+CisgICAgICAgIAorICAgIDxjb3B5cmlnaHQ+CisgICAgICAgICVjb3B5cmlnaHQKKyAgICA8L2NvcHlyaWdodD4KKyAgICAgICAgCisgICAgPGxpY2Vuc2UgdXJsPSIlbGljZW5zZVVSTCI+CisgICAgICAgICVsaWNlbnNlCisgICAgPC9saWNlbnNlPgorICAgICAgICAKKyAgICA8cGx1Z2luCisgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaSIKKyAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKKyAgICAgICAgaW5zdGFsbC1zaXplPSIwIgorICAgICAgICB2ZXJzaW9uPSIwLjAuMCIKKyAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgorICAgICAgICAKKzwvZmVhdHVyZT4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmZlYXR1cmUvbGljZW5zZS5odG1sIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZmVhdHVyZS9saWNlbnNlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmU1NzlhNQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmZlYXR1cmUvbGljZW5zZS5odG1sCkBAIC0wLDAgKzEsMTY0IEBACis8IS0tP3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJJU08tODg1OS0xIiA/LS0+Cis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+PGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIj4KKzx0aXRsZT5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L3RpdGxlPgorPC9oZWFkPgorCis8Ym9keSBsYW5nPSJFTi1VUyI+Cis8aDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9oMj4KKzxwPkZlYnJ1YXJ5IDEsIDIwMTE8L3A+CisKKzxoMz5Vc2FnZSBPZiBDb250ZW50PC9oMz4KKworPHA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTCisgICAoQ09MTEVDVElWRUxZICJDT05URU5UIikuICBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVSBBR1JFRSBUSEFUIFlPVVIgVVNFCisgICBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUgorICAgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC48L3A+CisKKzxoMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9oMz4KKworPHA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlCisgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSAKK0VjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAKKyAgICgiRVBMIikuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXMgQ29udGVudCBhbmQgaXMgYWxzbworIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgorCis8cD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgCitkb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gCitzb3VyY2UgY29kZQorICAgcmVwb3NpdG9yeSAoIlJlcG9zaXRvcnkiKSBpbiBzb2Z0d2FyZSBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIAorYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoIkRvd25sb2FkcyIpLjwvcD4KKworPHVsPgorICAgICAgIDxsaT5Db250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gCitmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgCittb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgiUGx1Zy1pbnMiKSwgcGx1Zy1pbiBmcmFnbWVudHMgCisoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLjwvbGk+CisgICAgICAgPGxpPkVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YSYjODQ4MjsgQVJjaGl2ZSkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgInBsdWdpbnMiLjwvbGk+CisgICAgICAgPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgCitGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgCitzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyAKK25hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIAorb2YgdGhlIFBsdWctaW5zCisgICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KKyAgICAgICA8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIAorRmVhdHVyZXMiKS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIAorbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy48L2xpPgorPC91bD4KKworPHA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSAKK2NvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZCAKK2NvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZAorSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAKKygiRmVhdHVyZSBMaWNlbnNlcyIpLiAgQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueQorIGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZQoraW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6PC9wPgorCis8dWw+CisgICAgICAgPGxpPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeTwvbGk+CisgICAgICAgPGxpPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzPC9saT4KKyAgICAgICA8bGk+SW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSczwvbGk+CisgICAgICAgPGxpPlN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnM8L2xpPgorICAgICAgIDxsaT5GZWF0dXJlIGRpcmVjdG9yaWVzPC9saT4KKzwvdWw+CisKKzxwPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIAoraW5zdGFsbGVkIHVzaW5nIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSAoYXMgZGVmaW5lZCBiZWxvdyksIHlvdSBtdXN0CisgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGUgTGljZW5zZSIpIGR1cmluZyB0aGUKK2luc3RhbGxhdGlvbiBwcm9jZXNzLiAgSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSAKK0ZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyBhbmQgCitjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IKK2luZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSAKK2ZvdW5kIGluIHRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIgCitmb3VuZCB3aXRoaW4gYSBGZWF0dXJlLgorU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMsIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSAKK3Rlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgCitnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbgordGhhdCBkaXJlY3RvcnkuPC9wPgorCis8cD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIAorVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuCisgIFNPTUUgT0YgVEhFU0UKK09USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9wPgorCis8dWw+CisgICAgICAgPGxpPkVjbGlwc2UgRGlzdHJpYnV0aW9uIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9saWNlbnNlcy9lZGwtdjEuMC5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRTwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjA8L2E+KTwvbGk+CisgICAgICAgPGxpPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgorPC91bD4KKworPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgCitDT05ESVRJT05TIFBSSU9SIFRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2UsIAorb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyBwcm92aWRlZCwgcGxlYXNlCitjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnMgCitnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgorCisKKzxoMz5Vc2Ugb2YgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3k8L2gzPgorCis8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBwcm92aXNpb25pbmcgc29mdHdhcmUsIAorZXhhbXBsZXMgb2Ygd2hpY2ggaW5jbHVkZSwgYnV0IGFyZSBub3QgbGltaXRlZCB0bywgcDIgYW5kIHRoZSBFY2xpcHNlCisgICBVcGRhdGUgTWFuYWdlciAoIlByb3Zpc2lvbmluZyBUZWNobm9sb2d5IikgZm9yIHRoZSBwdXJwb3NlIG9mIAorYWxsb3dpbmcgdXNlcnMgdG8gaW5zdGFsbCBzb2Z0d2FyZSwgZG9jdW1lbnRhdGlvbiwgaW5mb3JtYXRpb24gYW5kL29yCisgICBvdGhlciBtYXRlcmlhbHMgKGNvbGxlY3RpdmVseSAiSW5zdGFsbGFibGUgU29mdHdhcmUiKS4gVGhpcyAKK2NhcGFiaWxpdHkgaXMgcHJvdmlkZWQgd2l0aCB0aGUgaW50ZW50IG9mIGFsbG93aW5nIHN1Y2ggdXNlcnMgdG8KKyAgIGluc3RhbGwsIGV4dGVuZCBhbmQgdXBkYXRlIEVjbGlwc2UtYmFzZWQgcHJvZHVjdHMuIEluZm9ybWF0aW9uIGFib3V0IAorcGFja2FnaW5nIEluc3RhbGxhYmxlIFNvZnR3YXJlIGlzIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sIj5odHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sPC9hPgorICAgKCJTcGVjaWZpY2F0aW9uIikuPC9wPgorCis8cD5Zb3UgbWF5IHVzZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSB0byBhbGxvdyBvdGhlciBwYXJ0aWVzIHRvIGluc3RhbGwKKyBJbnN0YWxsYWJsZSBTb2Z0d2FyZS4gWW91IHNoYWxsIGJlIHJlc3BvbnNpYmxlIGZvciBlbmFibGluZyB0aGUKKyAgIGFwcGxpY2FibGUgbGljZW5zZSBhZ3JlZW1lbnRzIHJlbGF0aW5nIHRvIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSB0bworIGJlIHByZXNlbnRlZCB0bywgYW5kIGFjY2VwdGVkIGJ5LCB0aGUgdXNlcnMgb2YgdGhlIFByb3Zpc2lvbmluZyAKK1RlY2hub2xvZ3kKKyAgIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gQnkgdXNpbmcgUHJvdmlzaW9uaW5nIAorVGVjaG5vbG9neSBpbiBzdWNoIGEgbWFubmVyIGFuZCBtYWtpbmcgaXQgYXZhaWxhYmxlIGluIGFjY29yZGFuY2Ugd2l0aCAKK3RoZQorICAgU3BlY2lmaWNhdGlvbiwgeW91IGZ1cnRoZXIgYWNrbm93bGVkZ2UgeW91ciBhZ3JlZW1lbnQgdG8sIGFuZCB0aGUgCithY3F1aXNpdGlvbiBvZiBhbGwgbmVjZXNzYXJ5IHJpZ2h0cyB0byBwZXJtaXQgdGhlIGZvbGxvd2luZzo8L3A+CisKKzxvbD4KKyAgICAgICA8bGk+QSBzZXJpZXMgb2YgYWN0aW9ucyBtYXkgb2NjdXIgKCJQcm92aXNpb25pbmcgUHJvY2VzcyIpIGluIAord2hpY2ggYSB1c2VyIG1heSBleGVjdXRlIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neQorICAgICAgIG9uIGEgbWFjaGluZSAoIlRhcmdldCBNYWNoaW5lIikgd2l0aCB0aGUgaW50ZW50IG9mIGluc3RhbGxpbmcsIAorZXh0ZW5kaW5nIG9yIHVwZGF0aW5nIHRoZSBmdW5jdGlvbmFsaXR5IG9mIGFuIEVjbGlwc2UtYmFzZWQKKyAgICAgICBwcm9kdWN0LjwvbGk+CisgICAgICAgPGxpPkR1cmluZyB0aGUgUHJvdmlzaW9uaW5nIFByb2Nlc3MsIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSAKK21heSBjYXVzZSB0aGlyZCBwYXJ0eSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBvciBhIHBvcnRpb24gdGhlcmVvZiB0byBiZQorICAgICAgIGFjY2Vzc2VkIGFuZCBjb3BpZWQgdG8gdGhlIFRhcmdldCBNYWNoaW5lLjwvbGk+CisgICAgICAgPGxpPlB1cnN1YW50IHRvIHRoZSBTcGVjaWZpY2F0aW9uLCB5b3Ugd2lsbCBwcm92aWRlIHRvIHRoZSB1c2VyIAordGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuIHRoZSB1c2Ugb2YgdGhlIEluc3RhbGxhYmxlCisgICAgICAgU29mdHdhcmUgKCJJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQiKSBhbmQgc3VjaCBJbnN0YWxsYWJsZSAKK1NvZnR3YXJlIEFncmVlbWVudCBzaGFsbCBiZSBhY2Nlc3NlZCBmcm9tIHRoZSBUYXJnZXQKKyAgICAgICBNYWNoaW5lIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gU3VjaCBJbnN0YWxsYWJsZSAKK1NvZnR3YXJlIEFncmVlbWVudCBtdXN0IGluZm9ybSB0aGUgdXNlciBvZiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdAorIGdvdmVybgorICAgICAgIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBhbmQgbXVzdCBzb2xpY2l0IGFjY2VwdGFuY2UgYnkgdGhlIGVuZCAKK3VzZXIgaW4gdGhlIG1hbm5lciBwcmVzY3JpYmVkIGluIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50LiAKK1Vwb24gc3VjaAorICAgICAgIGluZGljYXRpb24gb2YgYWdyZWVtZW50IGJ5IHRoZSB1c2VyLCB0aGUgcHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgCit3aWxsIGNvbXBsZXRlIGluc3RhbGxhdGlvbiBvZiB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUuPC9saT4KKzwvb2w+CisKKzxoMz5DcnlwdG9ncmFwaHk8L2gzPgorCis8cD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUKKyBjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIAorYW5kL29yIHJlLWV4cG9ydCB0bworICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gCitzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIAorY29uY2VybmluZyB0aGUgaW1wb3J0LAorICAgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiAKK3RoaXMgaXMgcGVybWl0dGVkLjwvcD4KKworPHA+PHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgT3JhY2xlIENvcnBvcmF0aW9uIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguPC9zbWFsbD48L3A+CisKKworPC9ib2R5PjwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlL3BvbS54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlL3BvbS54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTFhNTY2NgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmZlYXR1cmUvcG9tLnhtbApAQCAtMCwwICsxLDY2IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzwhLS0jIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpLiAtLT4KKzwhLS0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgLS0+Cis8IS0tIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgLS0+Cis8IS0tIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAtLT4KKzwhLS0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIC0tPgorPCEtLSMgLS0+Cis8IS0tIyBDb250cmlidXRvcnM6IC0tPgorPCEtLSMgQ2hyaXN0b3BoZSBMb2V0eiAgKExvZXR6IEdtYkgmQ28uS0cpIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbiBBUEkgYW5kIGltcGxlbWVudGF0aW9uIC0tPgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzxwcm9qZWN0IHhtbG5zPSJodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9QT00vNC4wLjAiIHhtbG5zOnhzaT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEtaW5zdGFuY2UiIHhzaTpzY2hlbWFMb2NhdGlvbj0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIGh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL21hdmVuLXY0XzBfMC54c2QiPgorICAgIDxtb2RlbFZlcnNpb24+NC4wLjA8L21vZGVsVmVyc2lvbj4KKworICAgIDxwYXJlbnQ+CisgICAgICAgIDxncm91cElkPm9yZy5lY2xpcHNlLm9zYnAudWkuYXBpPC9ncm91cElkPgorICAgICAgICA8YXJ0aWZhY3RJZD5vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5hZ2dyZWdhdG9yPC9hcnRpZmFjdElkPgorICAgICAgICA8dmVyc2lvbj4wLjkuMC1TTkFQU0hPVDwvdmVyc2lvbj4KKyAgICA8L3BhcmVudD4KKworICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmZlYXR1cmU8L2FydGlmYWN0SWQ+CisgICAgPHBhY2thZ2luZz5lY2xpcHNlLWZlYXR1cmU8L3BhY2thZ2luZz4KKworICAgIDxidWlsZD4KKyAgICAgICAgPHBsdWdpbnM+CisgICAgICAgICAgICA8cGx1Z2luPgorICAgICAgICAgICAgICAgIDxncm91cElkPm9yZy5lY2xpcHNlLnR5Y2hvLmV4dHJhczwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD50eWNoby1zb3VyY2UtZmVhdHVyZS1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgPHZlcnNpb24+JHt0eWNob0V4dHJhc1ZlcnNpb259PC92ZXJzaW9uPgorICAgICAgICAgICAgICAgIDxleGVjdXRpb25zPgorICAgICAgICAgICAgICAgICAgICA8ZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgICAgICAgICAgPGlkPnNvdXJjZS1mZWF0dXJlPC9pZD4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxwaGFzZT5wYWNrYWdlPC9waGFzZT4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxnb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbD5zb3VyY2UtZmVhdHVyZTwvZ29hbD4KKyAgICAgICAgICAgICAgICAgICAgICAgIDwvZ29hbHM+CisgICAgICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9ucz4KKyAgICAgICAgICAgICAgICA8Y29uZmlndXJhdGlvbj4KKyAgICAgICAgICAgICAgICAgICAgPGxhYmVsU3VmZml4PiAoc291cmNlKTwvbGFiZWxTdWZmaXg+CisgICAgICAgICAgICAgICAgPC9jb25maWd1cmF0aW9uPgorICAgICAgICAgICAgPC9wbHVnaW4+CisgICAgICAgICAgICA8cGx1Z2luPgorICAgICAgICAgICAgICAgIDwhLS0gd29ya2Fyb3VuZCB3aGlsZSBidWcgaHR0cHM6Ly9idWdzLmVjbGlwc2Uub3JnL2J1Z3Mvc2hvd19idWcuY2dpP2lkPTM5ODI1MCAKKwkJCQkJaXMgbm90IGZpeGVkIC0tPgorICAgICAgICAgICAgICAgIDxncm91cElkPm9yZy5lY2xpcHNlLnR5Y2hvPC9ncm91cElkPgorICAgICAgICAgICAgICAgIDxhcnRpZmFjdElkPnR5Y2hvLXAyLXBsdWdpbjwvYXJ0aWZhY3RJZD4KKyAgICAgICAgICAgICAgICA8dmVyc2lvbj4ke3R5Y2hvLXZlcnNpb259PC92ZXJzaW9uPgorICAgICAgICAgICAgICAgIDxleGVjdXRpb25zPgorICAgICAgICAgICAgICAgICAgICA8ZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgICAgICAgICAgPGlkPmF0dGFjaGVkLXAyLW1ldGFkYXRhPC9pZD4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxwaGFzZT5wYWNrYWdlPC9waGFzZT4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxnb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbD5wMi1tZXRhZGF0YTwvZ29hbD4KKyAgICAgICAgICAgICAgICAgICAgICAgIDwvZ29hbHM+CisgICAgICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9ucz4KKyAgICAgICAgICAgIDwvcGx1Z2luPgorICAgICAgICA8L3BsdWdpbnM+CisgICAgPC9idWlsZD4KKworICAgIDxkZXBlbmRlbmNpZXM+CisgICAgCisgICAgPC9kZXBlbmRlbmNpZXM+CisKKzwvcHJvamVjdD4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLy5wcm9qZWN0IGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvLnByb2plY3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWU4YjhmNgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpLy5wcm9qZWN0CkBAIC0wLDAgKzEsNTEgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8cHJvamVjdERlc2NyaXB0aW9uPgorCTxuYW1lPm9yZy5lY2xpcHNlLm9zYnAudWkuYXBpPC9uYW1lPgorCTxjb21tZW50PjwvY29tbWVudD4KKwk8cHJvamVjdHM+CisJPC9wcm9qZWN0cz4KKwk8YnVpbGRTcGVjPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhYnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuTWFuaWZlc3RCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5TY2hlbWFCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLmJhYmVsLmVkaXRvci5yYmVCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLm0yZS5jb3JlLm1hdmVuMkJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLnNvbmFybGludC5lY2xpcHNlLmNvcmUuc29uYXJsaW50QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJPC9idWlsZFNwZWM+CisJPG5hdHVyZXM+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0TmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yTmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLlBsdWdpbk5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFuYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5iYWJlbC5lZGl0b3IucmJlTmF0dXJlPC9uYXR1cmU+CisJPC9uYXR1cmVzPgorPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9MSUNFTlNFLnR4dCBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL0xJQ0VOU0UudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZmNDJhZDQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9MSUNFTlNFLnR4dApAQCAtMCwwICsxLDE2MSBAQAorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtdiAxLjAKKworVEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSIFRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCJBR1JFRU1FTlQiKS4gQU5ZIFVTRSwgUkVQUk9EVUNUSU9OCitPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRSBPRiBUSElTIEFHUkVFTUVOVC4KKworMS4gREVGSU5JVElPTlMKKworIkNvbnRyaWJ1dGlvbiIgbWVhbnM6CisKK2EpIGluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbCBjb2RlIGFuZCBkb2N1bWVudGF0aW9uIGRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQKKworYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOgorCitpKSBjaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQKKworaWkpIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTsKKword2hlcmUgc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZCBieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuCitBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yIGlmIGl0IHdhcyBhZGRlZCB0byB0aGUgUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUKK2FjdGluZyBvbiBzdWNoIENvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZQorbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbiBjb25qdW5jdGlvbiB3aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdAorZGVyaXZhdGl2ZSB3b3JrcyBvZiB0aGUgUHJvZ3JhbS4KKworIkNvbnRyaWJ1dG9yIiBtZWFucyBhbnkgcGVyc29uIG9yIGVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLgorCisiTGljZW5zZWQgUGF0ZW50cyAiIG1lYW4gcGF0ZW50IGNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlIG9yIHNhbGUgb2YKK2l0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLgorCisiUHJvZ3JhbSIgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMgZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50LgorCisiUmVjaXBpZW50IiBtZWFucyBhbnlvbmUgd2hvIHJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy4KKworMi4gR1JBTlQgT0YgUklHSFRTCisKK2EpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvIHJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzIG9mLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlCithbmQgc3VibGljZW5zZSB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCitmb3JtLgorCitiKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBwYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0IGFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlCitDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQgbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUKK2NvbWJpbmF0aW9uIG9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZSBQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkIGJ5IHRoZSBDb250cmlidXRvciwgc3VjaAorYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbiB0byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90CithcHBseSB0byBhbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzIGxpY2Vuc2VkIGhlcmV1bmRlci4KKworYykgUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvciBncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cyBDb250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vCithc3N1cmFuY2VzIGFyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IgdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQorcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50IGZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5CitiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKK2xpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5IHRvIHNlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLCBpZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudCB0byBkaXN0cmlidXRlIHRoZQorUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZSB0aGF0IGxpY2Vuc2UgYmVmb3JlIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS4KKworZCkgRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQgcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8KK2dyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4gdGhpcyBBZ3JlZW1lbnQuCisKKzMuIFJFUVVJUkVNRU5UUworCitBIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSBpbiBvYmplY3QgY29kZSBmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6CisKK2EpIGl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgaXRzIGxpY2Vuc2UgYWdyZWVtZW50OgorCitpKSBlZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kIGNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZword2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlIGFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5IGFuZAorZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7CisKK2lpKSBlZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLCBpbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwKK2luY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaCBhcyBsb3N0IHByb2ZpdHM7CisKK2lpaSkgc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcyBBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdCBDb250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueQorb3RoZXIgcGFydHk7IGFuZAorCitpdikgc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZSBmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZCBpbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0CitpbiBhIHJlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYSBtZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuCisKK1doZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlIGNvZGUgZm9ybToKKworYSkgaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kCisKK2IpIGEgY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLgorCitDb250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55IGNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZCB3aXRoaW4gdGhlIFByb2dyYW0uCisKK0VhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlIG9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCitzdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4KKworNC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT04KKworQ29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5IGFjY2VwdCBjZXJ0YWluIHJlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMgYW5kCit0aGUgbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlIG9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzCit0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbCBsaWFiaWxpdHkgZm9yCitvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvcgorKCJDb21tZXJjaWFsIENvbnRyaWJ1dG9yIikgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kIGluZGVtbmlmeSBldmVyeSBvdGhlciBDb250cmlidXRvciAoIkluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIikKK2FnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQgY29zdHMgKGNvbGxlY3RpdmVseSAiTG9zc2VzIikgYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyIGxlZ2FsIGFjdGlvbnMKK2Jyb3VnaHQgYnkgYSB0aGlyZCBwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0byB0aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaAorQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiBjb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZy4gVGhlCitvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzIHJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwKK3Byb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIgdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCitDb250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB0byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQgYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkKKyBwYXJ0aWNpcGF0ZSBpbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuCisKK0ZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcwordGhlbiBhIENvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlIGNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMKK3JlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLgorVW5kZXIgdGhpcyBzZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUgb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8KK3Rob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEgY291cnQgcmVxdWlyZXMgYW55IG90aGVyIENvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwKK3RoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIG11c3QgcGF5IHRob3NlIGRhbWFnZXMuCisKKzUuIE5PIFdBUlJBTlRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IKK0NPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLCBXSVRIT1VUIExJTUlUQVRJT04sIEFOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsCitOT04tSU5GUklOR0VNRU5ULCBNRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseSByZXNwb25zaWJsZSBmb3IKK2RldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cworZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLCBjb21wbGlhbmNlCit3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IgZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuCisKKzYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVCBOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SIEFOWQorRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwKK0hPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IKK09USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVECitIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLgorCis3LiBHRU5FUkFMCisKK0lmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZCBvciB1bmVuZm9yY2VhYmxlIHVuZGVyIGFwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvcgorZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0IGZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaAorcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZSBtaW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuCisKK0lmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uIGFnYWluc3QgYW55IGVudGl0eSAoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkKK2FsbGVnaW5nIHRoYXQgdGhlIFByb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGggb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoCitSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaCBSZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlIHN1Y2gKK2xpdGlnYXRpb24gaXMgZmlsZWQuCisKK0FsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgc2hhbGwgdGVybWluYXRlIGlmIGl0IGZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IKK2NvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZSBwZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoCitub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kIGRpc3RyaWJ1dGlvbgorb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLCBSZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzCisgZ3JhbnRlZCBieSBSZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuCisKK0V2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlIGNvcGllcyBvZiB0aGlzIEFncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudAoraXMgY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUgQWdyZWVtZW50IFN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2gKK25ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nIHJldmlzaW9ucykgb2YgdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMgdGhlCityaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwgQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5Cithc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvIHNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbiBvZiB0aGUKK0FncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtIChpbmNsdWRpbmcgQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZQorZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZiB0aGUgQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24gb2YKK3RoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSAoaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUKK25ldyB2ZXJzaW9uLiBFeGNlcHQgYXMgZXhwcmVzc2x5IHN0YXRlZCBpbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCit0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlciBleHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvcgorb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdCBleHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuCisKK1RoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZSBTdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzCitvZiBBbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMgQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2UKK29mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMgaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL01FVEEtSU5GL01BTklGRVNULk1GIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvTUVUQS1JTkYvTUFOSUZFU1QuTUYKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmNmY2JmZQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL01FVEEtSU5GL01BTklGRVNULk1GCkBAIC0wLDAgKzEsNTAgQEAKK01hbmlmZXN0LVZlcnNpb246IDEuMAorQnVuZGxlLU1hbmlmZXN0VmVyc2lvbjogMgorQnVuZGxlLU5hbWU6IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpCitCdW5kbGUtU3ltYm9saWNOYW1lOiBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaQorQnVuZGxlLVZlcnNpb246IDAuOS4wLnF1YWxpZmllcgorUmVxdWlyZS1CdW5kbGU6IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZSwKKyBjb20udmFhZGluLnNlcnZlcjtidW5kbGUtdmVyc2lvbj0iNy41LjciCitCdW5kbGUtUmVxdWlyZWRFeGVjdXRpb25FbnZpcm9ubWVudDogSmF2YVNFLTEuOAorRXhwb3J0LVBhY2thZ2U6IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmNvbXBsZXhkYXRhY29udGFpbmVyO3ZlcnNpb249IjAuOS4wIiwKKyBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5jb250ZXh0ZnVuY3Rpb247dmVyc2lvbj0iMC45LjAiO3VzZXM6PSJjb20udmFhZGluLnVpIiwKKyBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5jdXN0b21maWVsZHM7dmVyc2lvbj0iMC45LjAiO3VzZXM6PSJjb20udmFhZGluLnNlcnZlcixvcmcuZWNsaXBzZS5lNC5jb3JlLnNlcnZpY2VzLmV2ZW50cyxjb20udmFhZGluLnVpIiwKKyBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5kYXRhbWFydDt2ZXJzaW9uPSIwLjkuMCIsCisgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZnVuY3Rpb25saWJyYXJ5O3ZlcnNpb249IjAuOS4wIjt1c2VzOj0ib3JnLmVjbGlwc2Uub3NicC51aS5hcGkuc3RhdGVtYWNoaW5lIiwKKyBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5sYXlvdXQ7dmVyc2lvbj0iMC45LjAiLAorIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLm1lc3NhZ2U7dmVyc2lvbj0iMC45LjAiLAorIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLm1ldGFkYXRhO3ZlcnNpb249IjAuOS4wIjt1c2VzOj0ib3JnLmVjbGlwc2UuZW1mLmVjb3JlLG9yZy5lY2xpcHNlLm9zYnAuZHNsLnh0ZXh0LnR5cGVzLmJ1bmRsZXMiLAorIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLm9yZ2FuaXphdGlvbjt2ZXJzaW9uPSIwLjkuMCIsCisgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkucG9zO3ZlcnNpb249IjAuOS4wIjt1c2VzOj0ib3JnLmVjbGlwc2Uub3NicC51aS5hcGkuc3RhdGVtYWNoaW5lIiwKKyBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5yZXBvcnQ7dmVyc2lvbj0iMC45LjAiLAorIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnN0YXRlbWFjaGluZTt2ZXJzaW9uPSIwLjkuMCI7CisgIHVzZXM6PSJvcmcuam9kYS50aW1lLAorICAgb3JnLmVjbGlwc2Uub3NicC5kc2wuZHRvLmxpYi5zZXJ2aWNlcywKKyAgIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnRoZW1lcywKKyAgIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLm1lc3NhZ2UsCisgICBvcmcuZWNsaXBzZS5vc2JwLmRzbC5jb21tb24uZGF0YXR5cGVzLAorICAgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkubWV0YWRhdGEsCisgICBvcmcuZWNsaXBzZS5vc2JwLmVjdmlldy5jb3JlLmNvbW1vbi5jb250ZXh0LAorICAgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudXNlciIsCisgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudGhlbWVzO3ZlcnNpb249IjAuOS4wIjt1c2VzOj0iY29tLnZhYWRpbi5zZXJ2ZXIiLAorIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXI7dmVyc2lvbj0iMC45LjAiO3VzZXM6PSJvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5jdXN0b21maWVsZHMsb3JnLmVjbGlwc2UuZTQudWkubW9kZWwuYXBwbGljYXRpb24iLAorIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3M7dmVyc2lvbj0iMC45LjAiO3VzZXM6PSJvcmcuZWNsaXBzZS5vc2JwLmRzbC5jb21tb24uZGF0YXR5cGVzLG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmNvbXBsZXhkYXRhY29udGFpbmVyLG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJmaWx0ZXIiLAorIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJmaWx0ZXI7dmVyc2lvbj0iMC45LjAiLAorIG9yZy5lY2xpcHNlLm9zYnAudWkuaW5pdGlhbGl6YXRpb247dmVyc2lvbj0iMC45LjAiCitJbXBvcnQtUGFja2FnZTogamF2YXgudmFsaWRhdGlvbjt2ZXJzaW9uPSIxLjEuMC5GaW5hbCIsCisgamF2YXgudmFsaWRhdGlvbi5jb25zdHJhaW50czt2ZXJzaW9uPSIxLjEuMC5GaW5hbCIsCisgbW9uZHJpYW4ucm9sYXA7dmVyc2lvbj0iMy41LjAiLAorIG9yZy5lY2xpcHNlLmU0LmNvcmUuc2VydmljZXMuZXZlbnRzLAorIG9yZy5lY2xpcHNlLmU0LnVpLm1vZGVsLmFwcGxpY2F0aW9uLAorIG9yZy5lY2xpcHNlLmVtZi5lY29yZSwKKyBvcmcuZWNsaXBzZS5vc2JwLmRzbC5jb21tb24uZGF0YXR5cGVzO3ZlcnNpb249IjAuOS4wIiwKKyBvcmcuZWNsaXBzZS5vc2JwLmRzbC5kdG8ubGliLnNlcnZpY2VzO3ZlcnNpb249IjAuOS4wIiwKKyBvcmcuZWNsaXBzZS5vc2JwLmRzbC54dGV4dC50eXBlcy5idW5kbGVzO3ZlcnNpb249IjAuOS4wIiwKKyBvcmcuZWNsaXBzZS5vc2JwLmVjdmlldy5jb3JlLmNvbW1vbi5jb250ZXh0O3ZlcnNpb249IjAuOS4wIiwKKyBvcmcuZWNsaXBzZS54dGV4dC5jb21tb24udHlwZXMsCisgb3JnLmVjbGlwc2UueHRleHQucmVzb3VyY2UsCisgb3JnLmVjbGlwc2UueHRleHQudXRpbCwKKyBvcmcuam9kYS50aW1lO3ZlcnNpb249IjIuNy4wIiwKKyBvcmcuc2xmNGo7cmVzb2x1dGlvbjo9b3B0aW9uYWwKK0J1bmRsZS1DbGFzc1BhdGg6IC4KK0J1bmRsZS1WZW5kb3I6IEVjbGlwc2UgT1NCUApkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvYWJvdXQuaHRtbCBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL2Fib3V0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjRjMDU5OAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL2Fib3V0Lmh0bWwKQEAgLTAsMCArMSwyOCBAQAorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIKKyAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiLz4KKzx0aXRsZT5BYm91dDwvdGl0bGU+Cis8L2hlYWQ+Cis8Ym9keSBsYW5nPSJFTi1VUyI+Cis8aDI+QWJvdXQgVGhpcyBDb250ZW50PC9oMj4KKyAKKzxwPkp1bmUgMSwgMjAxNjwvcD4JCis8aDM+TGljZW5zZTwvaDM+CisKKzxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAoJnF1b3Q7Q29udGVudCZxdW90OykuICBVbmxlc3Mgb3RoZXJ3aXNlIAoraW5kaWNhdGVkIGJlbG93LCB0aGUgQ29udGVudCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZQorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIGF2YWlsYWJsZSAKK2F0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCitGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgorCis8cD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSBDb250ZW50IGlzIAorYmVpbmcgcmVkaXN0cmlidXRlZCBieSBhbm90aGVyIHBhcnR5ICgmcXVvdDtSZWRpc3RyaWJ1dG9yJnF1b3Q7KSBhbmQgZGlmZmVyZW50IHRlcm1zIGFuZCBjb25kaXRpb25zIG1heQorYXBwbHkgdG8geW91ciB1c2Ugb2YgYW55IG9iamVjdCBjb2RlIGluIHRoZSBDb250ZW50LiAgQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIAorcHJvdmlkZWQgd2l0aCB0aGUgQ29udGVudC4gIElmIG5vIHN1Y2ggbGljZW5zZSBleGlzdHMsIGNvbnRhY3QgdGhlIFJlZGlzdHJpYnV0b3IuICBVbmxlc3Mgb3RoZXJ3aXNlCitpbmRpY2F0ZWQgYmVsb3csIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRVBMIHN0aWxsIGFwcGx5IHRvIGFueSBzb3VyY2UgY29kZSBpbiB0aGUgQ29udGVudAorYW5kIHN1Y2ggc291cmNlIGNvZGUgbWF5IGJlIG9idGFpbmVkIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnPC9hPi48L3A+CisKKzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9hYm91dC5pbmkgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9hYm91dC5pbmkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2RmNjcxZgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL2Fib3V0LmluaQpAQCAtMCwwICsxLDE3IEBACisjIGFib3V0LmluaQorIyBjb250YWlucyBpbmZvcm1hdGlvbiBhYm91dCBhIGZlYXR1cmUKKyMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKKyMgIiVrZXkiIGFyZSBleHRlcm5hbGl6ZWQgc3RyaW5ncyBkZWZpbmVkIGluIGFib3V0LnByb3BlcnRpZXMKKyMgVGhpcyBmaWxlIGRvZXMgbm90IG5lZWQgdG8gYmUgdHJhbnNsYXRlZC4KKworIyBQcm9wZXJ0eSAiYWJvdXRUZXh0IiBjb250YWlucyBibHVyYiBmb3IgIkFib3V0IiBkaWFsb2cgKHRyYW5zbGF0ZWQpCithYm91dFRleHQ9JWZlYXR1cmVUZXh0CisKKyMgUHJvcGVydHkgImZlYXR1cmVJbWFnZSIgY29udGFpbnMgcGF0aCB0byBmZWF0dXJlIGltYWdlICgzMngzMikKK2ZlYXR1cmVJbWFnZT0KKworIyBQcm9wZXJ0eSAiYXBwTmFtZSIgY29udGFpbnMgbmFtZSBvZiB0aGUgYXBwbGljYXRpb24gKHRyYW5zbGF0ZWQpCithcHBOYW1lPSVmZWF0dXJlTmFtZQorCisjIFByb3BlcnR5ICJ3ZWxjb21lUGFnZSIgY29udGFpbnMgcGF0aCB0byB3ZWxjb21lIHBhZ2UgKHNwZWNpYWwgWE1MLWJhc2VkIGZvcm1hdCkKK3dlbGNvbWVQYWdlPQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvYWJvdXQubWFwcGluZ3MgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9hYm91dC5tYXBwaW5ncwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40NTExYTBhCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvYWJvdXQubWFwcGluZ3MKQEAgLTAsMCArMSw2IEBACisjIGFib3V0Lm1hcHBpbmdzCisjIGNvbnRhaW5zIGZpbGwtaW5zIGZvciBhYm91dC5wcm9wZXJ0aWVzCisjIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCisjIFRoaXMgZmlsZSBkb2VzIG5vdCBuZWVkIHRvIGJlIHRyYW5zbGF0ZWQuCisKKzA9cXVhbGlmaWVyCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9hYm91dC5wcm9wZXJ0aWVzIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvYWJvdXQucHJvcGVydGllcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hYzU3ZDY2Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvYWJvdXQucHJvcGVydGllcwpAQCAtMCwwICsxLDI2IEBACisjCisjIENvcHlyaWdodCAoYykgMjAxMi0yMDE2IExvZXR6IEdtYkgmQ28uS0cKKyMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyMKKyMgQ29udHJpYnV0b3JzOgorIyAgICBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgorIworCisjIE5MU19NRVNTQUdFRk9STUFUX1ZBUgorCitmZWF0dXJlTmFtZT1vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaQorCisjIyMjIyMjIyMjIyMjIyMjIGJsdXJiIHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIworZmVhdHVyZVRleHQ9XAorQ29weXJpZ2h0IChjKSAyMDEyLTIwMTYsIExvZXR6IEdtYkgmQ28uS0cgXG5cCitBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzXG5cCithcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjBcblwKK3doaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0XG5cCitodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbFxuXAorXG5cCitDb250cmlidXRvcnM6XG5cCisgICAgQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uXG4KKyMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGJsdXJiIHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvYnVpbGQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL2J1aWxkLnByb3BlcnRpZXMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTM2NDAwNwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL2J1aWxkLnByb3BlcnRpZXMKQEAgLTAsMCArMSw4IEBACitzb3VyY2UuLiA9IHNyYy8KK291dHB1dC4uID0gdGFyZ2V0L2NsYXNzZXMvCitiaW4uaW5jbHVkZXMgPSBhYm91dC5wcm9wZXJ0aWVzLCAgYWJvdXQubWFwcGluZ3MsICBhYm91dC5pbmksICBhYm91dC5odG1sLCAgTUVUQS1JTkYvLFwKKyAgICAgICAgICAgICAgIC4sXAorICAgICAgICAgICAgICAgbGljZW5zZS5odG1sLFwKKyAgICAgICAgICAgICAgIExJQ0VOU0UudHh0CitzcmMuaW5jbHVkZXMgPSBhYm91dC5wcm9wZXJ0aWVzLCAgYWJvdXQubWFwcGluZ3MsICBhYm91dC5pbmksICBhYm91dC5odG1sLCAgTElDRU5TRS50eHQsXAorICAgICAgICAgICAgICAgbGljZW5zZS5odG1sCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9lcGwtdjEwLmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9lcGwtdjEwLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjM5OGFjYwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL2VwbC12MTAuaHRtbApAQCAtMCwwICsxLDI1OSBAQAorPCEtLT94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLTg4NTktMSIgPy0tPgorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgorPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPjxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSI+Cis8dGl0bGU+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIFZlcnNpb24gMS4wPC90aXRsZT4KKzxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+CisgIGJvZHkgeworICAgIHNpemU6IDguNWluIDExLjBpbjsKKyAgICBtYXJnaW46IDAuMjVpbiAwLjVpbiAwLjI1aW4gMC41aW47CisgICAgdGFiLWludGVydmFsOiAwLjVpbjsKKyAgICB9CisgIHAgeyAgCQorICAgIG1hcmdpbi1sZWZ0OiBhdXRvOworICAgIG1hcmdpbi10b3A6ICAwLjVlbTsKKyAgICBtYXJnaW4tYm90dG9tOiAwLjVlbTsKKyAgICB9CisgIHAubGlzdCB7CisgIAltYXJnaW4tbGVmdDogMC41aW47CisgICAgbWFyZ2luLXRvcDogIDAuMDVlbTsKKyAgICBtYXJnaW4tYm90dG9tOiAwLjA1ZW07CisgICAgfQorICA8L3N0eWxlPgorCis8L2hlYWQ+CisKKzxib2R5IGxhbmc9IkVOLVVTIj4KKworPGgyPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSB2IDEuMDwvaDI+CisKKzxwPlRIRSBBQ0NPTVBBTllJTkcgUFJPR1JBTSBJUyBQUk9WSURFRCBVTkRFUiBUSEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFCitQVUJMSUMgTElDRU5TRSAoIkFHUkVFTUVOVCIpLiBBTlkgVVNFLCBSRVBST0RVQ1RJT04gT1IKK0RJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFIE9GIFRISVMKK0FHUkVFTUVOVC48L3A+CisKKzxwPjxiPjEuIERFRklOSVRJT05TPC9iPjwvcD4KKworPHA+IkNvbnRyaWJ1dGlvbiIgbWVhbnM6PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YSkgaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsCitjb2RlIGFuZCBkb2N1bWVudGF0aW9uIGRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQ8L3A+Cis8cCBjbGFzcz0ibGlzdCI+YikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOjwvcD4KKzxwIGNsYXNzPSJsaXN0Ij5pKSBjaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQ8L3A+Cis8cCBjbGFzcz0ibGlzdCI+aWkpIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTs8L3A+Cis8cCBjbGFzcz0ibGlzdCI+d2hlcmUgc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0KK29yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQgYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLiBBCitDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvciBpZiBpdCB3YXMgYWRkZWQgdG8gdGhlCitQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZSBhY3Rpbmcgb24gc3VjaAorQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZQorUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZSBtb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluCitjb25qdW5jdGlvbiB3aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkKK2FyZSBub3QgZGVyaXZhdGl2ZSB3b3JrcyBvZiB0aGUgUHJvZ3JhbS48L3A+CisKKzxwPiJDb250cmlidXRvciIgbWVhbnMgYW55IHBlcnNvbiBvciBlbnRpdHkgdGhhdCBkaXN0cmlidXRlcwordGhlIFByb2dyYW0uPC9wPgorCis8cD4iTGljZW5zZWQgUGF0ZW50cyIgbWVhbiBwYXRlbnQgY2xhaW1zIGxpY2Vuc2FibGUgYnkgYQorQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlIG9yIHNhbGUgb2YgaXRzCitDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLjwvcD4KKworPHA+IlByb2dyYW0iIG1lYW5zIHRoZSBDb250cmlidXRpb25zIGRpc3RyaWJ1dGVkIGluIGFjY29yZGFuY2UKK3dpdGggdGhpcyBBZ3JlZW1lbnQuPC9wPgorCis8cD4iUmVjaXBpZW50IiBtZWFucyBhbnlvbmUgd2hvIHJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyCit0aGlzIEFncmVlbWVudCwgaW5jbHVkaW5nIGFsbCBDb250cmlidXRvcnMuPC9wPgorCis8cD48Yj4yLiBHUkFOVCBPRiBSSUdIVFM8L2I+PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YSkgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2gKK0NvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvIHJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzCitvZiwgcHVibGljbHkgZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgZGlzdHJpYnV0ZSBhbmQgc3VibGljZW5zZSB0aGUKK0NvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGFuZCBzdWNoIGRlcml2YXRpdmUgd29ya3MsIGluCitzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS48L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5iKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaAorQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsCitvZmZlciB0byBzZWxsLCBpbXBvcnQgYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2gKK0NvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudAorbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUgY29tYmluYXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlCitQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkIGJ5IHRoZSBDb250cmlidXRvciwKK3N1Y2ggYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbiB0byBiZSBjb3ZlcmVkCitieSB0aGUgTGljZW5zZWQgUGF0ZW50cy4gVGhlIHBhdGVudCBsaWNlbnNlIHNoYWxsIG5vdCBhcHBseSB0byBhbnkgb3RoZXIKK2NvbWJpbmF0aW9ucyB3aGljaCBpbmNsdWRlIHRoZSBDb250cmlidXRpb24uIE5vIGhhcmR3YXJlIHBlciBzZSBpcworbGljZW5zZWQgaGVyZXVuZGVyLjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmMpIFJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IKK2dyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzIENvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8gYXNzdXJhbmNlcworYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvciB0aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZQorcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaAorQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50IGZvciBjbGFpbXMgYnJvdWdodCBieQorYW55IG90aGVyIGVudGl0eSBiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cworb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kIGxpY2Vuc2VzCitncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eSB0bworc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IKK2V4YW1wbGUsIGlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50Cit0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlCit0aGF0IGxpY2Vuc2UgYmVmb3JlIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS48L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5kKSBFYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0CitoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQgcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8gZ3JhbnQKK3RoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4gdGhpcyBBZ3JlZW1lbnQuPC9wPgorCis8cD48Yj4zLiBSRVFVSVJFTUVOVFM8L2I+PC9wPgorCis8cD5BIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSBpbiBvYmplY3QgY29kZQorZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0OjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmEpIGl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMKK0FncmVlbWVudDsgYW5kPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YikgaXRzIGxpY2Vuc2UgYWdyZWVtZW50OjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmkpIGVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycworYWxsIHdhcnJhbnRpZXMgYW5kIGNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZyB3YXJyYW50aWVzCitvciBjb25kaXRpb25zIG9mIHRpdGxlIGFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yCitjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eSBhbmQgZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+aWkpIGVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzCithbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLCBpbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwKK2luY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaCBhcyBsb3N0IHByb2ZpdHM7PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+aWlpKSBzdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzCitBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdCBDb250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueSBvdGhlcgorcGFydHk7IGFuZDwvcD4KKworPHAgY2xhc3M9Imxpc3QiPml2KSBzdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlCitmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZCBpbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0IGluIGEKK3JlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYSBtZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUKK2V4Y2hhbmdlLjwvcD4KKworPHA+V2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UgY29kZSBmb3JtOjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmEpIGl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZDwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmIpIGEgY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaAorY29weSBvZiB0aGUgUHJvZ3JhbS48L3A+CisKKzxwPkNvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkgY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkCit3aXRoaW4gdGhlIFByb2dyYW0uPC9wPgorCis8cD5FYWNoIENvbnRyaWJ1dG9yIG11c3QgaWRlbnRpZnkgaXRzZWxmIGFzIHRoZSBvcmlnaW5hdG9yIG9mIGl0cworQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3Mgc3Vic2VxdWVudAorUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLjwvcD4KKworPHA+PGI+NC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT048L2I+PC9wPgorCis8cD5Db21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkgYWNjZXB0IGNlcnRhaW4KK3Jlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMgYW5kIHRoZQorbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlIG9mCit0aGUgUHJvZ3JhbSwgdGhlIENvbnRyaWJ1dG9yIHdobyBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwKK3Byb2R1Y3Qgb2ZmZXJpbmcgc2hvdWxkIGRvIHNvIGluIGEgbWFubmVyIHdoaWNoIGRvZXMgbm90IGNyZWF0ZQorcG90ZW50aWFsIGxpYWJpbGl0eSBmb3Igb3RoZXIgQ29udHJpYnV0b3JzLiBUaGVyZWZvcmUsIGlmIGEgQ29udHJpYnV0b3IKK2luY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yCisoIkNvbW1lcmNpYWwgQ29udHJpYnV0b3IiKSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQKK2luZGVtbmlmeSBldmVyeSBvdGhlciBDb250cmlidXRvciAoIkluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIikKK2FnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQgY29zdHMgKGNvbGxlY3RpdmVseSAiTG9zc2VzIikKK2FyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlciBsZWdhbCBhY3Rpb25zIGJyb3VnaHQgYnkgYSB0aGlyZAorcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8gdGhlIGV4dGVudCBjYXVzZWQgYnkgdGhlCithY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4gY29ubmVjdGlvbiB3aXRoIGl0cworZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLiBUaGUKK29ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMKK3JlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwgcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbgorb3JkZXIgdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5Cit0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZSBDb21tZXJjaWFsCitDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kIGFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUKK0luZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heSBwYXJ0aWNpcGF0ZSBpbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duCitleHBlbnNlLjwvcD4KKworPHA+Rm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwKK3Byb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcyB0aGVuIGEgQ29tbWVyY2lhbAorQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlCitjbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzIHJlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZQorY2xhaW1zIGFuZCB3YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eQorYWxvbmUuIFVuZGVyIHRoaXMgc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0bworZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZSBvdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0byB0aG9zZQorcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYSBjb3VydCByZXF1aXJlcyBhbnkgb3RoZXIKK0NvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IKK211c3QgcGF5IHRob3NlIGRhbWFnZXMuPC9wPgorCis8cD48Yj41LiBOTyBXQVJSQU5UWTwvYj48L3A+CisKKzxwPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUworUFJPVklERUQgT04gQU4gIkFTIElTIiBCQVNJUywgV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMKK09GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywgV0lUSE9VVCBMSU1JVEFUSU9OLAorQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwgTk9OLUlORlJJTkdFTUVOVCwgTUVSQ0hBTlRBQklMSVRZCitPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5CityZXNwb25zaWJsZSBmb3IgZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQKK2Rpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cworZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0bwordGhlIHJpc2tzIGFuZCBjb3N0cyBvZiBwcm9ncmFtIGVycm9ycywgY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywKK2RhbWFnZSB0byBvciBsb3NzIG9mIGRhdGEsIHByb2dyYW1zIG9yIGVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yCitpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy48L3A+CisKKzxwPjxiPjYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZPC9iPjwvcD4KKworPHA+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UCitOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULAorSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORworV0lUSE9VVCBMSU1JVEFUSU9OIExPU1QgUFJPRklUUyksIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GCitMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORworTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPUgorRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQKK0hFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuPC9wPgorCis8cD48Yj43LiBHRU5FUkFMPC9iPjwvcD4KKworPHA+SWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkIG9yIHVuZW5mb3JjZWFibGUgdW5kZXIKK2FwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvciBlbmZvcmNlYWJpbGl0eSBvZgordGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0IGZ1cnRoZXIgYWN0aW9uCitieSB0aGUgcGFydGllcyBoZXJldG8sIHN1Y2ggcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZSBtaW5pbXVtCitleHRlbnQgbmVjZXNzYXJ5IHRvIG1ha2Ugc3VjaCBwcm92aXNpb24gdmFsaWQgYW5kIGVuZm9yY2VhYmxlLjwvcD4KKworPHA+SWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24gYWdhaW5zdCBhbnkgZW50aXR5CisoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkgYWxsZWdpbmcgdGhhdCB0aGUKK1Byb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGggb3RoZXIKK3NvZnR3YXJlIG9yIGhhcmR3YXJlKSBpbmZyaW5nZXMgc3VjaCBSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaAorUmVjaXBpZW50J3MgcmlnaHRzIGdyYW50ZWQgdW5kZXIgU2VjdGlvbiAyKGIpIHNoYWxsIHRlcm1pbmF0ZSBhcyBvZiB0aGUKK2RhdGUgc3VjaCBsaXRpZ2F0aW9uIGlzIGZpbGVkLjwvcD4KKworPHA+QWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCBzaGFsbCB0ZXJtaW5hdGUgaWYgaXQKK2ZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IgY29uZGl0aW9ucyBvZiB0aGlzCitBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZSBwZXJpb2Qgb2YgdGltZQorYWZ0ZXIgYmVjb21pbmcgYXdhcmUgb2Ygc3VjaCBub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MgcmlnaHRzCit1bmRlciB0aGlzIEFncmVlbWVudCB0ZXJtaW5hdGUsIFJlY2lwaWVudCBhZ3JlZXMgdG8gY2Vhc2UgdXNlIGFuZAorZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGFzIHNvb24gYXMgcmVhc29uYWJseSBwcmFjdGljYWJsZS4gSG93ZXZlciwKK1JlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMgZ3JhbnRlZCBieQorUmVjaXBpZW50IHJlbGF0aW5nIHRvIHRoZSBQcm9ncmFtIHNoYWxsIGNvbnRpbnVlIGFuZCBzdXJ2aXZlLjwvcD4KKworPHA+RXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUgY29waWVzIG9mIHRoaXMKK0FncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudCBpcworY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUKK0FncmVlbWVudCBTdGV3YXJkIHJlc2VydmVzIHRoZSByaWdodCB0byBwdWJsaXNoIG5ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nCityZXZpc2lvbnMpIG9mIHRoaXMgQWdyZWVtZW50IGZyb20gdGltZSB0byB0aW1lLiBObyBvbmUgb3RoZXIgdGhhbiB0aGUKK0FncmVlbWVudCBTdGV3YXJkIGhhcyB0aGUgcmlnaHQgdG8gbW9kaWZ5IHRoaXMgQWdyZWVtZW50LiBUaGUgRWNsaXBzZQorRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbCBBZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkKK2Fzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8gc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEKK3N1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbiBvZiB0aGUgQWdyZWVtZW50IHdpbGwgYmUKK2dpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtIChpbmNsdWRpbmcKK0NvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUgZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZiB0aGUKK0FncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uCitvZiB0aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlCitQcm9ncmFtIChpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZSBuZXcgdmVyc2lvbi4gRXhjZXB0IGFzCitleHByZXNzbHkgc3RhdGVkIGluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubworcmlnaHRzIG9yIGxpY2Vuc2VzIHRvIHRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyCit0aGlzIEFncmVlbWVudCwgd2hldGhlciBleHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvcgorb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdCBleHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzCitBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLjwvcD4KKworPHA+VGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlIFN0YXRlIG9mIE5ldyBZb3JrIGFuZAordGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzIG9mIEFtZXJpY2EuIE5vIHBhcnR5Cit0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMgQWdyZWVtZW50IG1vcmUKK3RoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlIG9mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMgaXRzCityaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi48L3A+CisKKworCis8L2JvZHk+PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL2xpY2Vuc2UuaHRtbCBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL2xpY2Vuc2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZTU3OWE1Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvbGljZW5zZS5odG1sCkBAIC0wLDAgKzEsMTY0IEBACis8IS0tP3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJJU08tODg1OS0xIiA/LS0+Cis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+PGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIj4KKzx0aXRsZT5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L3RpdGxlPgorPC9oZWFkPgorCis8Ym9keSBsYW5nPSJFTi1VUyI+Cis8aDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9oMj4KKzxwPkZlYnJ1YXJ5IDEsIDIwMTE8L3A+CisKKzxoMz5Vc2FnZSBPZiBDb250ZW50PC9oMz4KKworPHA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTCisgICAoQ09MTEVDVElWRUxZICJDT05URU5UIikuICBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVSBBR1JFRSBUSEFUIFlPVVIgVVNFCisgICBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUgorICAgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC48L3A+CisKKzxoMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9oMz4KKworPHA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlCisgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSAKK0VjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAKKyAgICgiRVBMIikuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXMgQ29udGVudCBhbmQgaXMgYWxzbworIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgorCis8cD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgCitkb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gCitzb3VyY2UgY29kZQorICAgcmVwb3NpdG9yeSAoIlJlcG9zaXRvcnkiKSBpbiBzb2Z0d2FyZSBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIAorYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoIkRvd25sb2FkcyIpLjwvcD4KKworPHVsPgorICAgICAgIDxsaT5Db250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gCitmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgCittb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgiUGx1Zy1pbnMiKSwgcGx1Zy1pbiBmcmFnbWVudHMgCisoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLjwvbGk+CisgICAgICAgPGxpPkVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YSYjODQ4MjsgQVJjaGl2ZSkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgInBsdWdpbnMiLjwvbGk+CisgICAgICAgPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgCitGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgCitzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyAKK25hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIAorb2YgdGhlIFBsdWctaW5zCisgICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KKyAgICAgICA8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIAorRmVhdHVyZXMiKS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIAorbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy48L2xpPgorPC91bD4KKworPHA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSAKK2NvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZCAKK2NvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZAorSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAKKygiRmVhdHVyZSBMaWNlbnNlcyIpLiAgQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueQorIGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZQoraW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6PC9wPgorCis8dWw+CisgICAgICAgPGxpPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeTwvbGk+CisgICAgICAgPGxpPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzPC9saT4KKyAgICAgICA8bGk+SW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSczwvbGk+CisgICAgICAgPGxpPlN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnM8L2xpPgorICAgICAgIDxsaT5GZWF0dXJlIGRpcmVjdG9yaWVzPC9saT4KKzwvdWw+CisKKzxwPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIAoraW5zdGFsbGVkIHVzaW5nIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSAoYXMgZGVmaW5lZCBiZWxvdyksIHlvdSBtdXN0CisgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGUgTGljZW5zZSIpIGR1cmluZyB0aGUKK2luc3RhbGxhdGlvbiBwcm9jZXNzLiAgSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSAKK0ZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyBhbmQgCitjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IKK2luZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSAKK2ZvdW5kIGluIHRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIgCitmb3VuZCB3aXRoaW4gYSBGZWF0dXJlLgorU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMsIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSAKK3Rlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgCitnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbgordGhhdCBkaXJlY3RvcnkuPC9wPgorCis8cD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIAorVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuCisgIFNPTUUgT0YgVEhFU0UKK09USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9wPgorCis8dWw+CisgICAgICAgPGxpPkVjbGlwc2UgRGlzdHJpYnV0aW9uIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9saWNlbnNlcy9lZGwtdjEuMC5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRTwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjA8L2E+KTwvbGk+CisgICAgICAgPGxpPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgorPC91bD4KKworPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgCitDT05ESVRJT05TIFBSSU9SIFRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2UsIAorb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyBwcm92aWRlZCwgcGxlYXNlCitjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnMgCitnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgorCisKKzxoMz5Vc2Ugb2YgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3k8L2gzPgorCis8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBwcm92aXNpb25pbmcgc29mdHdhcmUsIAorZXhhbXBsZXMgb2Ygd2hpY2ggaW5jbHVkZSwgYnV0IGFyZSBub3QgbGltaXRlZCB0bywgcDIgYW5kIHRoZSBFY2xpcHNlCisgICBVcGRhdGUgTWFuYWdlciAoIlByb3Zpc2lvbmluZyBUZWNobm9sb2d5IikgZm9yIHRoZSBwdXJwb3NlIG9mIAorYWxsb3dpbmcgdXNlcnMgdG8gaW5zdGFsbCBzb2Z0d2FyZSwgZG9jdW1lbnRhdGlvbiwgaW5mb3JtYXRpb24gYW5kL29yCisgICBvdGhlciBtYXRlcmlhbHMgKGNvbGxlY3RpdmVseSAiSW5zdGFsbGFibGUgU29mdHdhcmUiKS4gVGhpcyAKK2NhcGFiaWxpdHkgaXMgcHJvdmlkZWQgd2l0aCB0aGUgaW50ZW50IG9mIGFsbG93aW5nIHN1Y2ggdXNlcnMgdG8KKyAgIGluc3RhbGwsIGV4dGVuZCBhbmQgdXBkYXRlIEVjbGlwc2UtYmFzZWQgcHJvZHVjdHMuIEluZm9ybWF0aW9uIGFib3V0IAorcGFja2FnaW5nIEluc3RhbGxhYmxlIFNvZnR3YXJlIGlzIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sIj5odHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sPC9hPgorICAgKCJTcGVjaWZpY2F0aW9uIikuPC9wPgorCis8cD5Zb3UgbWF5IHVzZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSB0byBhbGxvdyBvdGhlciBwYXJ0aWVzIHRvIGluc3RhbGwKKyBJbnN0YWxsYWJsZSBTb2Z0d2FyZS4gWW91IHNoYWxsIGJlIHJlc3BvbnNpYmxlIGZvciBlbmFibGluZyB0aGUKKyAgIGFwcGxpY2FibGUgbGljZW5zZSBhZ3JlZW1lbnRzIHJlbGF0aW5nIHRvIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSB0bworIGJlIHByZXNlbnRlZCB0bywgYW5kIGFjY2VwdGVkIGJ5LCB0aGUgdXNlcnMgb2YgdGhlIFByb3Zpc2lvbmluZyAKK1RlY2hub2xvZ3kKKyAgIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gQnkgdXNpbmcgUHJvdmlzaW9uaW5nIAorVGVjaG5vbG9neSBpbiBzdWNoIGEgbWFubmVyIGFuZCBtYWtpbmcgaXQgYXZhaWxhYmxlIGluIGFjY29yZGFuY2Ugd2l0aCAKK3RoZQorICAgU3BlY2lmaWNhdGlvbiwgeW91IGZ1cnRoZXIgYWNrbm93bGVkZ2UgeW91ciBhZ3JlZW1lbnQgdG8sIGFuZCB0aGUgCithY3F1aXNpdGlvbiBvZiBhbGwgbmVjZXNzYXJ5IHJpZ2h0cyB0byBwZXJtaXQgdGhlIGZvbGxvd2luZzo8L3A+CisKKzxvbD4KKyAgICAgICA8bGk+QSBzZXJpZXMgb2YgYWN0aW9ucyBtYXkgb2NjdXIgKCJQcm92aXNpb25pbmcgUHJvY2VzcyIpIGluIAord2hpY2ggYSB1c2VyIG1heSBleGVjdXRlIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neQorICAgICAgIG9uIGEgbWFjaGluZSAoIlRhcmdldCBNYWNoaW5lIikgd2l0aCB0aGUgaW50ZW50IG9mIGluc3RhbGxpbmcsIAorZXh0ZW5kaW5nIG9yIHVwZGF0aW5nIHRoZSBmdW5jdGlvbmFsaXR5IG9mIGFuIEVjbGlwc2UtYmFzZWQKKyAgICAgICBwcm9kdWN0LjwvbGk+CisgICAgICAgPGxpPkR1cmluZyB0aGUgUHJvdmlzaW9uaW5nIFByb2Nlc3MsIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSAKK21heSBjYXVzZSB0aGlyZCBwYXJ0eSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBvciBhIHBvcnRpb24gdGhlcmVvZiB0byBiZQorICAgICAgIGFjY2Vzc2VkIGFuZCBjb3BpZWQgdG8gdGhlIFRhcmdldCBNYWNoaW5lLjwvbGk+CisgICAgICAgPGxpPlB1cnN1YW50IHRvIHRoZSBTcGVjaWZpY2F0aW9uLCB5b3Ugd2lsbCBwcm92aWRlIHRvIHRoZSB1c2VyIAordGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuIHRoZSB1c2Ugb2YgdGhlIEluc3RhbGxhYmxlCisgICAgICAgU29mdHdhcmUgKCJJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQiKSBhbmQgc3VjaCBJbnN0YWxsYWJsZSAKK1NvZnR3YXJlIEFncmVlbWVudCBzaGFsbCBiZSBhY2Nlc3NlZCBmcm9tIHRoZSBUYXJnZXQKKyAgICAgICBNYWNoaW5lIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gU3VjaCBJbnN0YWxsYWJsZSAKK1NvZnR3YXJlIEFncmVlbWVudCBtdXN0IGluZm9ybSB0aGUgdXNlciBvZiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdAorIGdvdmVybgorICAgICAgIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBhbmQgbXVzdCBzb2xpY2l0IGFjY2VwdGFuY2UgYnkgdGhlIGVuZCAKK3VzZXIgaW4gdGhlIG1hbm5lciBwcmVzY3JpYmVkIGluIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50LiAKK1Vwb24gc3VjaAorICAgICAgIGluZGljYXRpb24gb2YgYWdyZWVtZW50IGJ5IHRoZSB1c2VyLCB0aGUgcHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgCit3aWxsIGNvbXBsZXRlIGluc3RhbGxhdGlvbiBvZiB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUuPC9saT4KKzwvb2w+CisKKzxoMz5DcnlwdG9ncmFwaHk8L2gzPgorCis8cD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUKKyBjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIAorYW5kL29yIHJlLWV4cG9ydCB0bworICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gCitzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIAorY29uY2VybmluZyB0aGUgaW1wb3J0LAorICAgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiAKK3RoaXMgaXMgcGVybWl0dGVkLjwvcD4KKworPHA+PHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgT3JhY2xlIENvcnBvcmF0aW9uIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguPC9zbWFsbD48L3A+CisKKworPC9ib2R5PjwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9wb20ueG1sIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvcG9tLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yYWFhOGZkCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvcG9tLnhtbApAQCAtMCwwICsxLDM2IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzwhLS0jIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIC0tPgorPCEtLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAtLT4KKzwhLS0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAtLT4KKzwhLS0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IC0tPgorPCEtLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgLS0+Cis8IS0tIyAtLT4KKzwhLS0jIENvbnRyaWJ1dG9yczogLS0+Cis8IS0tIyAgICAgQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24gLS0+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorCis8cHJvamVjdCB4bWxucz0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIiB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIiB4c2k6c2NoZW1hTG9jYXRpb249Imh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL1BPTS80LjAuMCBodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy94c2QvbWF2ZW4tNC4wLjAueHNkIj4KKyAgICA8bW9kZWxWZXJzaW9uPjQuMC4wPC9tb2RlbFZlcnNpb24+CisgICAgPGFydGlmYWN0SWQ+b3JnLmVjbGlwc2Uub3NicC51aS5hcGk8L2FydGlmYWN0SWQ+CisgICAgPGJ1aWxkPgorICAgICAgICA8c291cmNlRGlyZWN0b3J5PnNyYzwvc291cmNlRGlyZWN0b3J5PgorICAgICAgICA8cGx1Z2lucz4KKyAgICAgICAgPC9wbHVnaW5zPgorICAgIDwvYnVpbGQ+CisgICAgPHBhcmVudD4KKyAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2Uub3NicC51aS5hcGk8L2dyb3VwSWQ+CisgICAgICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmFnZ3JlZ2F0b3I8L2FydGlmYWN0SWQ+CisgICAgICAgIDx2ZXJzaW9uPjAuOS4wLVNOQVBTSE9UPC92ZXJzaW9uPgorICAgICAgICA8cmVsYXRpdmVQYXRoPi4uPC9yZWxhdGl2ZVBhdGg+CisgICAgPC9wYXJlbnQ+CisgICAgPHBhY2thZ2luZz5lY2xpcHNlLXBsdWdpbjwvcGFja2FnaW5nPgorICAgIDxkZXBlbmRlbmNpZXM+CisgICAgICAgIDxkZXBlbmRlbmN5PgorICAgICAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2Uub3NicC5kZXBlbmRlbmNpZXM8L2dyb3VwSWQ+CisgICAgICAgICAgICA8YXJ0aWZhY3RJZD5vcmcuZWNsaXBzZS5vc2JwLmRlcGVuZGVuY2llcy5mZWF0dXJlLnZhYWRpbjwvYXJ0aWZhY3RJZD4KKyAgICAgICAgICAgIDx2ZXJzaW9uPjcuNS43PC92ZXJzaW9uPgorICAgICAgICAgICAgPHR5cGU+ZWNsaXBzZS1mZWF0dXJlPC90eXBlPgorICAgICAgICA8L2RlcGVuZGVuY3k+CisgICAgPC9kZXBlbmRlbmNpZXM+Cis8L3Byb2plY3Q+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvY29tcGxleGRhdGFjb250YWluZXIvSUNvbXBsZXhEYXRhQ29udGFpbmVyLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvY29tcGxleGRhdGFjb250YWluZXIvSUNvbXBsZXhEYXRhQ29udGFpbmVyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzYwODc3MQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9jb21wbGV4ZGF0YWNvbnRhaW5lci9JQ29tcGxleERhdGFDb250YWluZXIuamF2YQpAQCAtMCwwICsxLDMzIEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmNvbXBsZXhkYXRhY29udGFpbmVyOworCisvKioKKyAqICBBbnkgY29tcGxleCBkYXRhIGNvbnRhaW5lciBtYXkgaW1wbGVtZW50IHRoaXMgaW50ZXJmYWNlLCB0byBicm9hZGNhc3QgY2hhbmdlcworICogIGluc2lkZSBpdHMgaW50ZXJuYWwgZGF0YS4KKyAqICAKKyAqICBBbnkgb3RoZXIgY2xhc3MgaW5zdGFuY2UgbWF5IGxpc3RlbiB0byBjaGFuZ2VzIGluc2lkZSB0aGUgaW50ZXJuYWwgZGF0YSBpbiB0aGlzIGNsYXNzLAorICogIHdpdGhvdXQgdGhlIG5lZWQgdG8ga25vdyBhYm91dCBhbnkgZGF0YSBzdHJ1Y3R1cmUgbmVjZXNzYXJ5LgorICovCitwdWJsaWMgaW50ZXJmYWNlIElDb21wbGV4RGF0YUNvbnRhaW5lciB7CisJCisJLyoqCisJICogQHBhcmFtIGxpc3RlbmVyICBhZGQgYW55IG90aGVyIGNsYXNzIGluc3RhbmNlIGFzIGFuIGxpc3RlbmVyIGZvciBpbnRlcm5hbCBkYXRhCisJICovCisJcHVibGljIHZvaWQgYWRkQ29tcGxleERhdGFDb250YWluZXJDaGFuZ2VkTGlzdGVuZXIoSUNvbXBsZXhEYXRhQ29udGFpbmVyQ2hhbmdlZExpc3RlbmVyIGxpc3RlbmVyKTsKKwkKKwkvKioKKwkgKiBAcGFyYW0gbGlzdGVuZXIgIHJlbW92ZSBhbnkgb3RoZXIgY2xhc3MgaW5zdGFuY2UgYXMgYW4gbGlzdGVuZXIgZm9yIGludGVybmFsIGRhdGEKKwkgKi8KKwlwdWJsaWMgdm9pZCByZW1vdmVDb21wbGV4RGF0YUNvbnRhaW5lckNoYW5nZWRMaXN0ZW5lcihJQ29tcGxleERhdGFDb250YWluZXJDaGFuZ2VkTGlzdGVuZXIgbGlzdGVuZXIpOworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2NvbXBsZXhkYXRhY29udGFpbmVyL0lDb21wbGV4RGF0YUNvbnRhaW5lckNoYW5nZWRMaXN0ZW5lci5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2NvbXBsZXhkYXRhY29udGFpbmVyL0lDb21wbGV4RGF0YUNvbnRhaW5lckNoYW5nZWRMaXN0ZW5lci5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmEwNDY4ZWUKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvY29tcGxleGRhdGFjb250YWluZXIvSUNvbXBsZXhEYXRhQ29udGFpbmVyQ2hhbmdlZExpc3RlbmVyLmphdmEKQEAgLTAsMCArMSwyNSBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5jb21wbGV4ZGF0YWNvbnRhaW5lcjsKKworLyoqCisgKiAgQW55IGNsYXNzIGluc3RhbmNlIG1heSBsaXN0ZW4gdG8gY2hhbmdlcyBpbnNpZGUgdGhlIGludGVybmFsIGRhdGEgb2YgYSBjb21wbGV4IGRhdGEgY29udGFpbmVyLAorICogIHdpdGhvdXQgdGhlIG5lZWQgdG8ga25vdyBhYm91dCBpdHMgZGF0YSBzdHJ1Y3R1cmUgbmVjZXNzYXJ5LgorICovCitwdWJsaWMgaW50ZXJmYWNlIElDb21wbGV4RGF0YUNvbnRhaW5lckNoYW5nZWRMaXN0ZW5lciB7CisJCisJLyoqCisJICogVGhlIGludGVybmFsIGRhdGEgb2YgYW55IGNvbXBsZXggZGF0YSBjb250YWluZXIgbGlzdGVuZWQgdG8gaGFzIGJlZW4gY2hhbmdlZC4KKwkgKi8KKwlwdWJsaWMgdm9pZCBjb21wbGV4RGF0YUNvbnRhaW5lckNoYW5nZWQoKTsKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9jb250ZXh0ZnVuY3Rpb24vSVVzZXJGaWx0ZXJEaWFsb2dQcm92aWRlci5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2NvbnRleHRmdW5jdGlvbi9JVXNlckZpbHRlckRpYWxvZ1Byb3ZpZGVyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDM1ZTg3ZAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9jb250ZXh0ZnVuY3Rpb24vSVVzZXJGaWx0ZXJEaWFsb2dQcm92aWRlci5qYXZhCkBAIC0wLDAgKzEsMzggQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuY29udGV4dGZ1bmN0aW9uOworCitpbXBvcnQgY29tLnZhYWRpbi51aS5Db21wb25lbnQ7CitpbXBvcnQgY29tLnZhYWRpbi51aS5WZXJ0aWNhbExheW91dDsKKworLy8gVE9ETzogQXV0by1nZW5lcmF0ZWQgSmF2YWRvYworLyoqCisgKiBUaGUgSW50ZXJmYWNlIElVc2VyRmlsdGVyRGlhbG9nUHJvdmlkZXIuIFVzZWQgdG8gaW5qZWN0IGEgZGlhbG9nIHRvIG1haW50YWluIHVzZXIgZmlsdGVycy4KKyAqLworcHVibGljIGludGVyZmFjZSBJVXNlckZpbHRlckRpYWxvZ1Byb3ZpZGVyIHsKKwkKKwkvKioKKwkgKiBHZXRzIHRoZSBkaWFsb2cuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBkaWFsb2cKKwkgKi8KKwlDb21wb25lbnQgZ2V0RGlhbG9nKCk7CisJCisJLyoqCisJICogQ3JlYXRlcyB0aGUgdmlldy4KKwkgKgorCSAqIEBwYXJhbSBwYXJlbnQKKwkgKiAgICAgICAgICAgIHRoZSBwYXJlbnQgbGF5b3V0IHRoZSB2aWV3IHdpbGwgYmUgYXR0YWNoZWQgdG8uCisJICovCisJdm9pZCBjcmVhdGVWaWV3KGZpbmFsIFZlcnRpY2FsTGF5b3V0IHBhcmVudCk7Cit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvY29udGV4dGZ1bmN0aW9uL0lVc2VyTWVudVByb3ZpZGVyLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvY29udGV4dGZ1bmN0aW9uL0lVc2VyTWVudVByb3ZpZGVyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDRlYWRmOQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9jb250ZXh0ZnVuY3Rpb24vSVVzZXJNZW51UHJvdmlkZXIuamF2YQpAQCAtMCwwICsxLDE5IEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmNvbnRleHRmdW5jdGlvbjsKKworaW1wb3J0IGNvbS52YWFkaW4udWkuQ29tcG9uZW50OworCitwdWJsaWMgaW50ZXJmYWNlIElVc2VyTWVudVByb3ZpZGVyIHsKKwlDb21wb25lbnQgZ2V0TWVudSgpOworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2NvbnRleHRmdW5jdGlvbi9JVmFhZGluRGlhbG9nUHJvdmlkZXIuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9jb250ZXh0ZnVuY3Rpb24vSVZhYWRpbkRpYWxvZ1Byb3ZpZGVyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDBkYjI1MwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9jb250ZXh0ZnVuY3Rpb24vSVZhYWRpbkRpYWxvZ1Byb3ZpZGVyLmphdmEKQEAgLTAsMCArMSwzOCBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5jb250ZXh0ZnVuY3Rpb247CisKK2ltcG9ydCBjb20udmFhZGluLnVpLkNvbXBvbmVudDsKK2ltcG9ydCBjb20udmFhZGluLnVpLlZlcnRpY2FsTGF5b3V0OworCisvLyBUT0RPOiBBdXRvLWdlbmVyYXRlZCBKYXZhZG9jCisvKioKKyAqIFRoZSBJbnRlcmZhY2UgSVZhYWRpbkRpYWxvZ1Byb3ZpZGVyLiBVc2VkIHRvIGluamVjdCBhIHZhYWRpbiBiYXNlZCBkaWFsb2cuCisgKi8KK3B1YmxpYyBpbnRlcmZhY2UgSVZhYWRpbkRpYWxvZ1Byb3ZpZGVyIHsKKwkKKwkvKioKKwkgKiBHZXRzIHRoZSBkaWFsb2cgY29tcG9uZW50LgorCSAqCisJICogQHJldHVybiB0aGUgZGlhbG9nCisJICovCisJQ29tcG9uZW50IGdldERpYWxvZygpOworCQorCS8qKgorCSAqIENyZWF0ZXMgdGhlIHZpZXcuCisJICoKKwkgKiBAcGFyYW0gcGFyZW50CisJICogICAgICAgICAgICB0aGUgcGFyZW50IGxheW91dCB0aGUgdmlldyB3aWxsIGJlIGF0dGFjaGVkIHRvLgorCSAqLworCXZvaWQgY3JlYXRlVmlldyhmaW5hbCBWZXJ0aWNhbExheW91dCBwYXJlbnQpOworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2NvbnRleHRmdW5jdGlvbi9JVmlld0VtYmVkZGVkUHJvdmlkZXIuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9jb250ZXh0ZnVuY3Rpb24vSVZpZXdFbWJlZGRlZFByb3ZpZGVyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTU0NTA1ZAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9jb250ZXh0ZnVuY3Rpb24vSVZpZXdFbWJlZGRlZFByb3ZpZGVyLmphdmEKQEAgLTAsMCArMSwyMCBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5jb250ZXh0ZnVuY3Rpb247CisKK2ltcG9ydCBjb20udmFhZGluLnVpLlZlcnRpY2FsTGF5b3V0OworCitwdWJsaWMgaW50ZXJmYWNlIElWaWV3RW1iZWRkZWRQcm92aWRlciB7CisJdm9pZCBjcmVhdGVWaWV3KGZpbmFsIFZlcnRpY2FsTGF5b3V0IHBhcmVudCk7CisJdm9pZCBjcmVhdGVDb21wb25lbnRzKCk7Cit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvY3VzdG9tZmllbGRzL0lCbG9iVXBsb2FkQ29tcG9uZW50LmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvY3VzdG9tZmllbGRzL0lCbG9iVXBsb2FkQ29tcG9uZW50LmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGM1YmE1NwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9jdXN0b21maWVsZHMvSUJsb2JVcGxvYWRDb21wb25lbnQuamF2YQpAQCAtMCwwICsxLDE0MSBAQAorLyoKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogIENvcHlyaWdodCAoYykgMjAxMSAtIDIwMTYgLSBMb2V0eiBHbWJIICYgQ28gS0csIDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqICBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqICBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgSW5pdGlhbCBjb250cmlidXRpb246ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgTG9ldHogR21iSCAmIENvLiBLRworICogCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuY3VzdG9tZmllbGRzOworCitpbXBvcnQgamF2YS51dGlsLkxpc3Q7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5lNC5jb3JlLnNlcnZpY2VzLmV2ZW50cy5JRXZlbnRCcm9rZXI7CisKK2ltcG9ydCBjb20udmFhZGluLnNlcnZlci5SZXNvdXJjZTsKK2ltcG9ydCBjb20udmFhZGluLnVpLkxhYmVsOworCitwdWJsaWMgaW50ZXJmYWNlIElCbG9iVXBsb2FkQ29tcG9uZW50IHsKKwlwdWJsaWMgZW51bSBCVVRUT05fQUxJR05NRU5UIHsKKwkJVE9QLCBCVVRUT00sIExFRlQsIFJJR0hULCBERUZBVUxUCisJfQorCisJLyoqCisJICogRW5hYmxlcyB0aGUgdXBsb2FkIGJ1dHRvbi4KKwkgKgorCSAqIEBwYXJhbSB1cGxvYWRCdXR0b24KKwkgKiAgICAgICAgICAgIHRoZSB1cGxvYWQgYnV0dG9uCisJICovCisJdm9pZCBlbmFibGVVcGxvYWRCdXR0b24oYm9vbGVhbiB1cGxvYWRCdXR0b24pOworCisJLyoqCisJICogU2V0cyB0aGUgcmVzb2x1dGlvbiBmb3IgdGhlIGJsb2IgdG8gYmUgZGlzcGxheWVkIHZpYSByZXNvbHV0aW9uIGlkCisJICogCisJICogQHBhcmFtIGRpc3BsYXlSZXNvbHV0aW9uSWQKKwkgKi8KKwl2b2lkIHNldERpc3BsYXlSZXNvbHV0aW9uSWQoaW50IGRpc3BsYXlSZXNvbHV0aW9uSWQpOworCQorCS8qKgorCSAqIFNldHMgdGhlIHJlc29sdXRpb24gZm9yIHRoZSBibG9iIHRvIGJlIGRpc3BsYXllZCB2aWEgcmVzb2x1dGlvbiBzdHJpbmcKKwkgKgorCSAqIEBwYXJhbSBkaXNwbGF5UmVzb2x1dGlvbiB0aGUgbmV3IGRpc3BsYXkgcmVzb2x1dGlvbgorCSAqLworCXZvaWQgc2V0RGlzcGxheVJlc29sdXRpb24oU3RyaW5nIGRpc3BsYXlSZXNvbHV0aW9uKTsKKwkvKioKKwkgKiBTZXRzIHRoZSB1dWlkIGZvciB0aGUgYmxvYiB0byBiZSBkaXNwbGF5ZWQKKwkgKiAKKwkgKiBAcGFyYW0gdW5pcXVlTmFtZQorCSAqLworCXZvaWQgc2V0VXBsb2FkZWRVbmlxdWVOYW1lKFN0cmluZyB1bmlxdWVOYW1lKTsKKworCS8qKgorCSAqIFNldHMgdGhlIGZpcm1seSBsaW5rZWQuCisJICoKKwkgKiBAcGFyYW0gZmlybWx5TGlua2VkCisJICogICAgICAgICAgICB0aGUgbmV3IGZpcm1seSBsaW5rZWQKKwkgKi8KKwl2b2lkIHNldEZpcm1seUxpbmtlZChib29sZWFuIGZpcm1seUxpbmtlZCk7CisKKwkvKioKKwkgKiBDaGVja3MgaWYgY29tcG9uZW50IGlzIGZpcm1seSBsaW5rZWQuCisJICoKKwkgKiBAcmV0dXJuIHRydWUsIGlmIGlzIGZpcm1seSBsaW5rZWQKKwkgKi8KKwlib29sZWFuIGlzRmlybWx5TGlua2VkKCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSBldmVudCBicm9rZXIuCisJICoKKwkgKiBAcGFyYW0gZXZlbnRCcm9rZXIgdGhlIG5ldyBldmVudCBicm9rZXIKKwkgKi8KKwl2b2lkIHNldEV2ZW50QnJva2VyKElFdmVudEJyb2tlciBldmVudEJyb2tlcik7CisKKwkvKioKKwkgKiBTZXRzIHRoZSBkaXNwbGF5IGltYWdlIGxhYmVsLgorCSAqCisJICogQHBhcmFtIGRpc3BsYXlJbWFnZUxhYmVsIHRoZSBuZXcgZGlzcGxheSBpbWFnZSBsYWJlbAorCSAqLworCXZvaWQgc2V0RGlzcGxheUltYWdlTGFiZWwoTGFiZWwgZGlzcGxheUltYWdlTGFiZWwpOworCisJLyoqCisJICogU2V0cyB0aGUgYnV0dG9uIGFsaWdubWVudC4KKwkgKgorCSAqIEBwYXJhbSBidXR0b25BbGlnbm1lbnQgdGhlIG5ldyBidXR0b24gYWxpZ25tZW50CisJICovCisJdm9pZCBzZXRVcGxvYWRCdXR0b25BbGlnbm1lbnQoQlVUVE9OX0FMSUdOTUVOVCBidXR0b25BbGlnbm1lbnQpOworCisJLyoqCisJICogQ2hlY2tzIGlmIGlzIHVuaXF1ZSBuYW1lIGVuYWJsZWQuCisJICoKKwkgKiBAcmV0dXJuIHRydWUsIGlmIGlzIHVuaXF1ZSBuYW1lIGVuYWJsZWQKKwkgKi8KKwlib29sZWFuIGlzVW5pcXVlTmFtZUVuYWJsZWQoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIHVuaXF1ZSBuYW1lIGVuYWJsZWQuCisJICoKKwkgKiBAcGFyYW0gdW5pcXVlTmFtZUVuYWJsZWQgdGhlIG5ldyB1bmlxdWUgbmFtZSBlbmFibGVkCisJICovCisJdm9pZCBzZXRVbmlxdWVOYW1lRW5hYmxlZChib29sZWFuIHVuaXF1ZU5hbWVFbmFibGVkKTsKKwkKKwkvKioKKwkgKiBTZXRzIHRoZSB1cGxvYWQgY29tcG9uZW50IGxhYmVsLgorCSAqCisJICogQHBhcmFtIGxhYmVsIHRoZSBuZXcgYmxvYiB1cGxvYWQgY29tcCBsYWJlbAorCSAqLworCXZvaWQgc2V0QmxvYlVwbG9hZENvbXBMYWJlbChMYWJlbCBsYWJlbCk7CisJCisJLyoqCisJICogU2V0cyB0aGUgdXBsb2FkIGJ1dHRvbiBjYXB0aW9uLgorCSAqCisJICogQHBhcmFtIGJ1dHRvbkNhcHRpb24gdGhlIG5ldyB1cGxvYWQgYnV0dG9uIGNhcHRpb24KKwkgKi8KKwl2b2lkIHNldFVwbG9hZEJ1dHRvbkNhcHRpb24oU3RyaW5nIGJ1dHRvbkNhcHRpb24pOworCQorCS8qKgorCSAqIFNldHMgdGhlIHVwbG9hZCBpY29uLgorCSAqCisJICogQHBhcmFtIHVwbG9hZEljb24gdGhlIG5ldyB1cGxvYWQgaWNvbgorCSAqLworCXZvaWQgc2V0VXBsb2FkSWNvbihSZXNvdXJjZSB1cGxvYWRJY29uKTsKKwkKKwkvKioKKwkgKiBTZXRzIHRoZSBkb3dubG9hZCBpY29uLgorCSAqCisJICogQHBhcmFtIGRvd25sb2FkSWNvbiB0aGUgbmV3IGRvd25sb2FkIGljb24KKwkgKi8KKwl2b2lkIHNldERvd25sb2FkSWNvbihSZXNvdXJjZSBkb3dubG9hZEljb24pOworCQorCS8qKgorCSAqIFNldHMgdGhlIHVwbG9hZCBhY2NlcHRlZCBtaW1lIHR5cGVzLgorCSAqCisJICogQHBhcmFtIG1pbWVUeXBlcyB0aGUgbmV3IHVwbG9hZCBhY2NlcHRlZCBtaW1lIHR5cGVzCisJICovCisJdm9pZCBzZXRVcGxvYWRBY2NlcHRlZE1pbWVUeXBlcyhMaXN0PFN0cmluZz4gbWltZVR5cGVzKTsKKwkKK30KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvZGF0YW1hcnQvRGVyaXZlZE9sYXBFeGNlcHRpb24uamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9kYXRhbWFydC9EZXJpdmVkT2xhcEV4Y2VwdGlvbi5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjZjNjk0NmEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvZGF0YW1hcnQvRGVyaXZlZE9sYXBFeGNlcHRpb24uamF2YQpAQCAtMCwwICsxLDI4IEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiAgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogIENvbnRyaWJ1dG9yczogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIAkgICBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqIAorICovCisgcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5kYXRhbWFydDsKKworcHVibGljIGNsYXNzIERlcml2ZWRPbGFwRXhjZXB0aW9uIGV4dGVuZHMgRXhjZXB0aW9uIHsKKworCXB1YmxpYyBEZXJpdmVkT2xhcEV4Y2VwdGlvbihTdHJpbmcgbWVzc2FnZSkgeworCQlzdXBlcihtZXNzYWdlKTsKKwl9CisKKwkvKioKKwkgKiAKKwkgKi8KKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAxTDsKKworCQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2RhdGFtYXJ0L0lEYXRhTWFydC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2RhdGFtYXJ0L0lEYXRhTWFydC5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJiZmVkZmQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvZGF0YW1hcnQvSURhdGFNYXJ0LmphdmEKQEAgLTAsMCArMSw0MiBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5kYXRhbWFydDsKKworaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7CitpbXBvcnQgamF2YS51dGlsLkhhc2hNYXA7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS51c2VyLklVc2VyOworCitwdWJsaWMgaW50ZXJmYWNlIElEYXRhTWFydCB7CisgICAgcHVibGljIGVudW0gRVR5cGUgeworICAgICAgICBCT09MRUFOLCBEQVRFLCBGTE9BVCwgRE9VQkxFLCBCWVRFLCBTSE9SVCwgSU5URUdFUiwgTE9ORywgU1RSSU5HLCBUSU1FLCBCTE9QTUFQUElORywgTEVOVU0sIG5vbmUKKyAgICB9CisgICAgCisJcHVibGljIGZpbmFsIHN0YXRpYyBTdHJpbmcgREFUQU1BUlRfQ0xBU1NfUE9TVEZJWCA9ICJEYXRhbWFydCI7CisJcHVibGljIGZpbmFsIHN0YXRpYyBTdHJpbmcgREFUQU1BUlRfSURfQ09MVU1OX1BSRUZJWCA9ICJfXyI7CisJcHVibGljIGZpbmFsIHN0YXRpYyBTdHJpbmcgREFUQU1BUlRfSURfQ09MVU1OX1BPU1RGSVggPSAiX19JRF9fIjsKKwkKKwlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyAgc2luZ2xlU2VsZWN0RGVjb3JhdG9yID0gIiQiOworCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nICBtdWx0aVNlbGVjdERlY29yYXRvciA9ICLCpyI7CisJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgIGV4Y2VwdERlY29yYXRvciA9ICIlIjsKKwlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyAgc2xpY2VyU2luZ2xlU2VsZWN0RGVjb3JhdG9yID0gIj8iOworCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nICBzbGljZXJNdWx0aVNlbGVjdERlY29yYXRvciA9ICIhIjsKKwlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyAgc3FsRmlsdGVyTm90aGluZyA9ICInKiciOworCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nICBmaWx0ZXJJZFBsYWNlaG9sZGVyID0gIiYiOworCQorCXB1YmxpYyBzdGF0aWMgU3RyaW5nIGRlY29yYXRlKFN0cmluZyBkZWNvcmF0b3IsIFN0cmluZyBpbnB1dCkge3JldHVybiBkZWNvcmF0b3IraW5wdXQrZGVjb3JhdG9yO30KKworCXB1YmxpYyBhYnN0cmFjdCBIYXNoTWFwPFN0cmluZywgQXJyYXlMaXN0PElEdWFsRGF0YT4+IGdldEZpbHRlcnMoSVVzZXIgdXNlcik7CisJcHVibGljIGFic3RyYWN0IEhhc2hNYXA8U3RyaW5nLCBFVHlwZT4gZ2V0SWRNYXAoKTsKKwlwdWJsaWMgYWJzdHJhY3QgSGFzaE1hcDxTdHJpbmcsIEVUeXBlPiBnZXRUeXBlc01hcChJVXNlciB1c2VyKTsKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9kYXRhbWFydC9JRGF0YW1hcnRGaWx0ZXJHZW5lcmF0b3IuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9kYXRhbWFydC9JRGF0YW1hcnRGaWx0ZXJHZW5lcmF0b3IuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wYjQ3NjM3Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2RhdGFtYXJ0L0lEYXRhbWFydEZpbHRlckdlbmVyYXRvci5qYXZhCkBAIC0wLDAgKzEsNDQgQEAKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZGF0YW1hcnQ7CisKK2ltcG9ydCBqYXZhLnV0aWwuTG9jYWxlOworaW1wb3J0IGphdmEudXRpbC5NYXA7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5sYXlvdXQuSVZpZXdMYXlvdXRNYW5hZ2VyOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLm1ldGFkYXRhLklEU0xNZXRhZGF0YVNlcnZpY2U7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudXNlci5JVXNlcjsKKworaW1wb3J0IGNvbS52YWFkaW4uZGF0YS5Qcm9wZXJ0eS5WYWx1ZUNoYW5nZUxpc3RlbmVyOworCitwdWJsaWMgaW50ZXJmYWNlIElEYXRhbWFydEZpbHRlckdlbmVyYXRvciB7CisJdm9pZCBzZXREc2xNZXRhZGF0YVNlcnZpY2UoSURTTE1ldGFkYXRhU2VydmljZSBkc2xNZXRhZGF0YVNlcnZpY2UpOworCisJYm9vbGVhbiBjcmVhdGVGaWx0ZXIoSURhdGFNYXJ0IGRhdGFtYXJ0LCBJVXNlciB1c2VyLAorCQkJVmFsdWVDaGFuZ2VMaXN0ZW5lciBmaWx0ZXJDaGFuZ2VMaXN0ZW5lciwKKwkJCUlWaWV3TGF5b3V0TWFuYWdlciBsYXlvdXRNYW5hZ2VyKTsKKworCWJvb2xlYW4gY3JlYXRlRmlsdGVyKElEYXRhTWFydCBkYXRhbWFydCwgSVVzZXIgdXNlciwKKwkJCVZhbHVlQ2hhbmdlTGlzdGVuZXIgZmlsdGVyQ2hhbmdlTGlzdGVuZXIsCisJCQlJVmlld0xheW91dE1hbmFnZXIgbGF5b3V0TWFuYWdlciwgYm9vbGVhbiBzaG93Q2FwdGlvbik7CisKKwl2b2lkIHNldElkKFN0cmluZyBpZFByb3BlcnR5LCBTdHJpbmcgaWQpOworCisJdm9pZCByZXNldElkKCk7CisKKwlNYXA8U3RyaW5nLCBJRGF0YW1hcnRTZWxlY3RhYmxlPiBnZXRTZWxlY3RvcnMoKTsKKworCWJvb2xlYW4gaXNDdWJlKCk7CisKKwl2b2lkIHNldEN1YmUoYm9vbGVhbiBjdWJlKTsKKworCXZvaWQgcmVzZXRJdGVtKFN0cmluZyBmaWx0ZXIpOworCisJTWFwPFN0cmluZywgU3RyaW5nPiBnZXRGaWx0ZXIoYm9vbGVhbiBpc0N1YmUpOworCisJdm9pZCBzZXRMb2NhbGUoTG9jYWxlIGxvY2FsZSk7CisKKwl2b2lkIHNlbGVjdEl0ZW0oU3RyaW5nIGZpbHRlciwgU3RyaW5nIHNlbGVjdGlvbik7CisKKwl2b2lkIHVwZGF0ZUZpbHRlcihJRGF0YU1hcnQgZGF0YW1hcnQsIElVc2VyIHVzZXIsCisJCQlWYWx1ZUNoYW5nZUxpc3RlbmVyIGZpbHRlckNoYW5nZUxpc3RlbmVyKTsKKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2RhdGFtYXJ0L0lEYXRhbWFydFNlbGVjdGFibGUuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9kYXRhbWFydC9JRGF0YW1hcnRTZWxlY3RhYmxlLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjUwMjg5MQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9kYXRhbWFydC9JRGF0YW1hcnRTZWxlY3RhYmxlLmphdmEKQEAgLTAsMCArMSwxNTEgQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZGF0YW1hcnQ7CisKK2ltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKK2ltcG9ydCBqYXZhLnV0aWwuTGlzdDsKKworaW1wb3J0IGNvbS52YWFkaW4uZGF0YS5Db250YWluZXI7CitpbXBvcnQgY29tLnZhYWRpbi5kYXRhLlByb3BlcnR5LlZhbHVlQ2hhbmdlTGlzdGVuZXI7CitpbXBvcnQgY29tLnZhYWRpbi5zZXJ2ZXIuU2l6ZWFibGUuVW5pdDsKKworcHVibGljIGludGVyZmFjZSBJRGF0YW1hcnRTZWxlY3RhYmxlIHsKKwkKKwkvKioKKwkgKiBDaGVja3MgaWYgaXMgc2xpY2VyLgorCSAqCisJICogQHJldHVybiB0cnVlLCBpZiBpcyBzbGljZXIKKwkgKi8KKwlib29sZWFuIGlzU2xpY2VyKCk7CisJCisJLyoqCisJICogQ2hlY2tzIGlmIGlzIG11bHRpIHNlbGVjdGVkLgorCSAqCisJICogQHJldHVybiB0cnVlLCBpZiBpcyBtdWx0aSBzZWxlY3RlZAorCSAqLworCWJvb2xlYW4gaXNNdWx0aVNlbGVjdGVkKCk7CisJCisJLyoqCisJICogVXBkYXRlIHRoZSBjb21ibyBib3guCisJICoKKwkgKiBAcGFyYW0gb3B0aW9ucyB0aGUgZHVhbCBkYXRhIGl0ZW1zIAorCSAqLworCXZvaWQgdXBkYXRlKENvbGxlY3Rpb248SUR1YWxEYXRhPiBvcHRpb25zKTsKKwkKKwkvKioKKwkgKiBHZXRzIHRoZSBmaWx0ZXIgbmFtZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGZpbHRlciBuYW1lCisJICovCisJU3RyaW5nIGdldEZpbHRlck5hbWUoKTsKKwkKKwkvKioKKwkgKiBTZXRzIHRoZSBmaWx0ZXIgbmFtZS4KKwkgKgorCSAqIEBwYXJhbSBmaWx0ZXJOYW1lIHRoZSBuZXcgZmlsdGVyIG5hbWUKKwkgKi8KKwl2b2lkIHNldEZpbHRlck5hbWUoU3RyaW5nIGZpbHRlck5hbWUpOworCQorCS8qKgorCSAqIEdldHMgdGhlIHNlbGVjdGVkIGl0ZW1zLgorCSAqCisJICogQHJldHVybiB0aGUgc2VsZWN0ZWQgaXRlbXMKKwkgKi8KKwlMaXN0PElEdWFsRGF0YT4gZ2V0U2VsZWN0ZWRJdGVtcygpOworCQorCU9iamVjdCBnZXRWYWx1ZSgpOworCQorCS8qKgorCSAqIEdldHMgdGhlIGZpcnN0IGl0ZW0uCisJICoKKwkgKiBAcmV0dXJuIHRoZSBmaXJzdCBpdGVtIG1hdGNoaW5nCisJICovCisJSUR1YWxEYXRhIGdldEZpcnN0SXRlbSgpOworCQorCS8qKgorCSAqIEdldHMgdGhlIGhpZXJhcmNoeSBpZiBhbnkuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBoaWVyYXJjaHkKKwkgKi8KKwlTdHJpbmcgZ2V0SGllcmFyY2h5KCk7CisJCisJLyoqCisJICogU2V0cyB0aGUgaGllcmFyY2h5LgorCSAqCisJICogQHBhcmFtIGhpZXJhcmNoeSB0aGUgbmV3IGhpZXJhcmNoeQorCSAqLworCXZvaWQgc2V0SGllcmFyY2h5KFN0cmluZyBoaWVyYXJjaHkpOworCQorCS8qKgorCSAqIEdldHMgdGhlIGNvbnRhaW5lciBkYXRhc291cmNlIG9mIHRoZSB1bmRlcmx5aW5nIGNvbWJvYm94LgorCSAqCisJICogQHJldHVybiB0aGUgY29udGFpbmVyIGRhdGFzb3VyY2UKKwkgKi8KKwlDb250YWluZXIgZ2V0Q29udGFpbmVyRGF0YVNvdXJjZSgpOworCQorCS8qKgorCSAqIFNlbGVjdCBhbiBpdGVtIGluIHRoZSB1bmRlcmx5aW5nIGNvbWJvYm94CisJICoKKwkgKiBAcGFyYW0gb2JqIHRoZSBvYmoKKwkgKi8KKwl2b2lkIHNlbGVjdChPYmplY3Qgb2JqKTsKKwkKKwkvKioKKwkgKiBBZGRzIHRoZSB2YWx1ZSBjaGFuZ2UgbGlzdGVuZXIuCisJICoKKwkgKiBAcGFyYW0gbGlzdGVuZXIgdGhlIGxpc3RlbmVyCisJICovCisJdm9pZCBhZGRWYWx1ZUNoYW5nZUxpc3RlbmVyKFZhbHVlQ2hhbmdlTGlzdGVuZXIgbGlzdGVuZXIpOworCQorCS8qKgorCSAqIFJlbW92ZXMgdGhlIHZhbHVlIGNoYW5nZSBsaXN0ZW5lci4KKwkgKgorCSAqIEBwYXJhbSBsaXN0ZW5lciB0aGUgbGlzdGVuZXIKKwkgKi8KKwl2b2lkIHJlbW92ZVZhbHVlQ2hhbmdlTGlzdGVuZXIoVmFsdWVDaGFuZ2VMaXN0ZW5lciBsaXN0ZW5lcik7CisJLyoqCisJICogU2V0cyB0aGUgY2FwdGlvbi4KKwkgKgorCSAqIEBwYXJhbSBjYXB0aW9uIHRoZSBuZXcgY2FwdGlvbgorCSAqLworCXZvaWQgc2V0Q2FwdGlvbihTdHJpbmcgY2FwdGlvbik7CisJCisJLyoqCisJICogU2V0cyB0aGUgZGVzY3JpcHRpb24uCisJICoKKwkgKiBAcGFyYW0gZGVzY3JpcHRpb24gdGhlIG5ldyBkZXNjcmlwdGlvbgorCSAqLworCXZvaWQgc2V0RGVzY3JpcHRpb24oU3RyaW5nIGRlc2NyaXB0aW9uKTsKKwkKKwkvKioKKwkgKiBHZXRzIHRoZSBoZWlnaHQuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBoZWlnaHQKKwkgKi8KKwlmbG9hdCBnZXRIZWlnaHQoKTsKKwkKKwkvKioKKwkgKiBHZXRzIHRoZSBoZWlnaHQgdW5pdHMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBoZWlnaHQgdW5pdHMKKwkgKi8KKwlVbml0IGdldEhlaWdodFVuaXRzKCk7CisJCisJLyoqCisJICogU2V0cyB0aGUgd2lkdGguCisJICoKKwkgKiBAcGFyYW0gd2lkdGggdGhlIG5ldyB3aWR0aAorCSAqLworCXZvaWQgc2V0V2lkdGgoU3RyaW5nIHdpZHRoKTsKKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2RhdGFtYXJ0L0lEdWFsRGF0YS5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2RhdGFtYXJ0L0lEdWFsRGF0YS5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY3OGY4ZGUKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvZGF0YW1hcnQvSUR1YWxEYXRhLmphdmEKQEAgLTAsMCArMSw2OSBAQAorLyoKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogIENvcHlyaWdodCAoYykgMjAxMSAtIDIwMTcgLSBMb2V0eiBHbWJIICYgQ28gS0csIDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqICBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiAgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqICBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgSW5pdGlhbCBjb250cmlidXRpb246ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgTG9ldHogR21iSCAmIENvLiBLRworICogCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZGF0YW1hcnQ7CisKKy8qKgorICogVGhlIEludGVyZmFjZSBJRHVhbERhdGEuCisgKi8KK3B1YmxpYyBpbnRlcmZhY2UgSUR1YWxEYXRhIHsKKwkKKwkvKioKKwkgKiBHZXRzIHRoZSBzZWxlY3Rpb24gdmFsdWUuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBzZWxlY3Rpb24gdmFsdWUKKwkgKi8KKwlTdHJpbmcgZ2V0U2VsZWN0aW9uVmFsdWUoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIHNlbGVjdGlvbiB2YWx1ZS4KKwkgKgorCSAqIEBwYXJhbSB2YWx1ZSB0aGUgbmV3IHNlbGVjdGlvbiB2YWx1ZQorCSAqLworCXZvaWQgc2V0U2VsZWN0aW9uVmFsdWUoU3RyaW5nIHZhbHVlKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGZvcm1hdHRlZCB2YWx1ZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGZvcm1hdHRlZCB2YWx1ZQorCSAqLworCVN0cmluZyBnZXRGb3JtYXR0ZWRWYWx1ZSgpOworCisJLyoqCisJICogR2V0cyB0aGUgc2lnbmlmaWNhbnQgdmFsdWUuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBzaWduaWZpY2FudCB2YWx1ZQorCSAqLworCVN0cmluZyBnZXRTaWduaWZpY2FudFZhbHVlKCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSBmb3JtYXR0ZWQgdmFsdWUuCisJICoKKwkgKiBAcGFyYW0gZm9ybWF0dGVkVmFsdWUgdGhlIG5ldyBmb3JtYXR0ZWQgdmFsdWUKKwkgKi8KKwl2b2lkIHNldEZvcm1hdHRlZFZhbHVlKFN0cmluZyBmb3JtYXR0ZWRWYWx1ZSk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSB1bmZvcm1hdHRlZCB2YWx1ZS4KKwkgKgorCSAqIEBwYXJhbSB1bmZvcm1hdHRlZFZhbHVlIHRoZSBuZXcgdW5mb3JtYXR0ZWQgdmFsdWUKKwkgKi8KKwl2b2lkIHNldFVuZm9ybWF0dGVkVmFsdWUoU3RyaW5nIHVuZm9ybWF0dGVkVmFsdWUpOworCisJLyoqCisJICogR2V0cyB0aGUgaGllcmFyY2h5LgorCSAqCisJICogQHJldHVybiB0aGUgaGllcmFyY2h5CisJICovCisJU3RyaW5nIGdldEhpZXJhcmNoeSgpOworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2Z1bmN0aW9ubGlicmFyeS9JRnVuY3Rpb25MaWJyYXJ5R3JvdXAuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9mdW5jdGlvbmxpYnJhcnkvSUZ1bmN0aW9uTGlicmFyeUdyb3VwLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2VmNDdlYwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9mdW5jdGlvbmxpYnJhcnkvSUZ1bmN0aW9uTGlicmFyeUdyb3VwLmphdmEKQEAgLTAsMCArMSwxOCBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mdW5jdGlvbmxpYnJhcnk7CisKKy8vVE9ETyBWZXJzaW9uIDIgLSBtb3ZlIHRvIEFQSSBwYWNrYWdlCitwdWJsaWMgaW50ZXJmYWNlIElGdW5jdGlvbkxpYnJhcnlHcm91cCB7CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9mdW5jdGlvbmxpYnJhcnkvSUZ1bmN0aW9uTGlicmFyeVBhY2thZ2UuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9mdW5jdGlvbmxpYnJhcnkvSUZ1bmN0aW9uTGlicmFyeVBhY2thZ2UuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yMzUyMDA3Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL2Z1bmN0aW9ubGlicmFyeS9JRnVuY3Rpb25MaWJyYXJ5UGFja2FnZS5qYXZhCkBAIC0wLDAgKzEsMTggQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuZnVuY3Rpb25saWJyYXJ5OworCisvLyBUT0RPIFZlcnNpb24gMiAtIG1vdmUgdG8gQVBJIHBhY2thZ2UKK3B1YmxpYyBpbnRlcmZhY2UgSUZ1bmN0aW9uTGlicmFyeVBhY2thZ2UgeworCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvZnVuY3Rpb25saWJyYXJ5L0lGdW5jdGlvbkxpYnJhcnlTZXJ2aWNlLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvZnVuY3Rpb25saWJyYXJ5L0lGdW5jdGlvbkxpYnJhcnlTZXJ2aWNlLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjA5MWJjZAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9mdW5jdGlvbmxpYnJhcnkvSUZ1bmN0aW9uTGlicmFyeVNlcnZpY2UuamF2YQpAQCAtMCwwICsxLDQzIEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiAgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogIENvbnRyaWJ1dG9yczogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIAkgICBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqIAorICovCisgcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mdW5jdGlvbmxpYnJhcnk7CisKK2ltcG9ydCBqYXZhLnV0aWwuTG9jYWxlOworCitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuc3RhdGVtYWNoaW5lLklTdGF0ZU1hY2hpbmU7CisKKy8qKgorICogVGhpcyBzZXJ2aWNlIHByb3ZpZGVzIGFjY2VzcyB0byB0aGUgZnVuY3Rpb24gbGlicmFyeS4KKyAqLworcHVibGljIGludGVyZmFjZSBJRnVuY3Rpb25MaWJyYXJ5U2VydmljZSB7CisKKwlwdWJsaWMgT2JqZWN0IGNhbGxGdW5jdGlvbkxpYnJhcnkoU3RyaW5nIGNsYXNzTmFtZSwgU3RyaW5nIG1ldGhvZE5hbWUsCisJCQlPYmplY3QgZmllbGRWYWx1ZSwgTG9jYWxlIGxvY2FsZSwgT2JqZWN0Li4uIHBhcmFtcyk7CisKKwlwdWJsaWMgT2JqZWN0IGNhbGxGdW5jdGlvbkxpYnJhcnkoU3RyaW5nIGNsYXNzTmFtZSwgU3RyaW5nIG1ldGhvZE5hbWUsCisJCQlPYmplY3QgZmllbGRWYWx1ZSk7CisKKwlwdWJsaWMgT2JqZWN0IGNhbGxGdW5jdGlvbkxpYnJhcnkoU3RyaW5nIGNsYXNzTmFtZSwgU3RyaW5nIG1ldGhvZE5hbWUsCisJCQlMb2NhbGUgbG9jYWxlKTsKKworCXB1YmxpYyBPYmplY3QgY2FsbEZ1bmN0aW9uTGlicmFyeShTdHJpbmcgY2xhc3NOYW1lLCBTdHJpbmcgbWV0aG9kTmFtZSk7CisKKwlwdWJsaWMgYm9vbGVhbiBndWFyZChJU3RhdGVNYWNoaW5lIHN0YXRlbWFjaGluZSwgU3RyaW5nIGNsYXNzTmFtZSwgU3RyaW5nIG1ldGhvZE5hbWUpOworCisJcHVibGljIGJvb2xlYW4gb3BlcmF0aW9uKElTdGF0ZU1hY2hpbmUgc3RhdGVtYWNoaW5lLCBTdHJpbmcgY2xhc3NOYW1lLAorCQkJU3RyaW5nIG1ldGhvZE5hbWUsIE9iamVjdC4uLiBwYXJhbXMpOworCisJcHVibGljIE9iamVjdCBmdW5jdGlvbihJU3RhdGVNYWNoaW5lIHN0YXRlbWFjaGluZSwgU3RyaW5nIGNsYXNzTmFtZSwKKwkJCVN0cmluZyBtZXRob2ROYW1lLCBPYmplY3QuLi4gcGFyYW1zKTsKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9sYXlvdXQvSVZpZXdMYXlvdXRNYW5hZ2VyLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvbGF5b3V0L0lWaWV3TGF5b3V0TWFuYWdlci5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjgzNzBlM2UKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvbGF5b3V0L0lWaWV3TGF5b3V0TWFuYWdlci5qYXZhCkBAIC0wLDAgKzEsMTYgQEAKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkubGF5b3V0OworCitpbXBvcnQgY29tLnZhYWRpbi5zZXJ2ZXIuRXh0ZW5zaW9uOworaW1wb3J0IGNvbS52YWFkaW4udWkuQWJzdHJhY3RPcmRlcmVkTGF5b3V0OworaW1wb3J0IGNvbS52YWFkaW4udWkuSG9yaXpvbnRhbExheW91dDsKK2ltcG9ydCBjb20udmFhZGluLnVpLlZlcnRpY2FsTGF5b3V0OworCitwdWJsaWMgaW50ZXJmYWNlIElWaWV3TGF5b3V0TWFuYWdlciB7CisJdm9pZCBpbml0KEFic3RyYWN0T3JkZXJlZExheW91dCBwYXJlbnQpOworCXZvaWQgYWRkRXh0ZW5zaW9uKEV4dGVuc2lvbiBleHRlbnNpb24pOworCXZvaWQgcmVtb3ZlRXh0ZW5zaW9uKEV4dGVuc2lvbiBleHRlbnNpb24pOworCXZvaWQgc2V0TGFiZWxWYWx1ZShTdHJpbmcgdGV4dCk7CisJSG9yaXpvbnRhbExheW91dCBnZXRUb3BBcmVhKCk7CisJVmVydGljYWxMYXlvdXQgZ2V0U2lkZUFyZWEoKTsKKwlWZXJ0aWNhbExheW91dCBnZXREYXRhQXJlYSgpOworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL21lc3NhZ2UvSU1lc3NhZ2VSZXF1ZXN0ZXIuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9tZXNzYWdlL0lNZXNzYWdlUmVxdWVzdGVyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTAwM2E1OQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9tZXNzYWdlL0lNZXNzYWdlUmVxdWVzdGVyLmphdmEKQEAgLTAsMCArMSwxMSBAQAorcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5tZXNzYWdlOworCitwdWJsaWMgaW50ZXJmYWNlIElNZXNzYWdlUmVxdWVzdGVyIHsKKwl2b2lkIGFkZEJ1dHRvbkxpc3RlbmVyKElNZXNzYWdlUmVxdWVzdGVyLkNsaWNrUmVjaXBpZW50IHJlY2lwaWVudCk7CisJdm9pZCByZW1vdmVCdXR0b25MaXN0ZW5lcihJTWVzc2FnZVJlcXVlc3Rlci5DbGlja1JlY2lwaWVudCByZWNpcGllbnQpOworCQorCXB1YmxpYyBpbnRlcmZhY2UgQ2xpY2tSZWNpcGllbnQgZXh0ZW5kcyBqYXZhLnV0aWwuRXZlbnRMaXN0ZW5lciB7CisJCXZvaWQgbWVzc2FnZUJ1dHRvblByZXNzZWQoTWVzc2FnZVJlcXVlc3RlckV2ZW50IGUpOworCX0KKwkKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9tZXNzYWdlL01lc3NhZ2VFdmVudC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL21lc3NhZ2UvTWVzc2FnZUV2ZW50LmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODE1NGZmZAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9tZXNzYWdlL01lc3NhZ2VFdmVudC5qYXZhCkBAIC0wLDAgKzEsMjcgQEAKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkubWVzc2FnZTsKKworcHVibGljIGNsYXNzIE1lc3NhZ2VFdmVudCB7CisJcHVibGljIGVudW0gRXZlbnRUeXBlIHsKKwkJS0VZQk9BUkQsIFRSSUdHRVIsIElELCBNRVNTQUdFT1BFTiwgTUVTU0FHRUNMT1NFLCBFUlJPUiwgU1RBVFVTT1BFTiwgU1RBVFVTQ0xPU0U7CisJfTsKKwkKKwlwcml2YXRlIEV2ZW50VHlwZSB0eXBlOworCXByaXZhdGUgU3RyaW5nIGlkOworCXB1YmxpYyBNZXNzYWdlRXZlbnQoRXZlbnRUeXBlIHR5cGUsIFN0cmluZyBpZCkgeworCQl0aGlzLnR5cGUgPSB0eXBlOworCQl0aGlzLmlkID0gaWQ7CisJfQorCXB1YmxpYyBFdmVudFR5cGUgZ2V0VHlwZSgpIHsKKwkJcmV0dXJuIHR5cGU7CisJfQorCXB1YmxpYyB2b2lkIHNldFR5cGUoRXZlbnRUeXBlIHR5cGUpIHsKKwkJdGhpcy50eXBlID0gdHlwZTsKKwl9CisJcHVibGljIFN0cmluZyBnZXRJZCgpIHsKKwkJcmV0dXJuIGlkOworCX0KKwlwdWJsaWMgdm9pZCBzZXRJZChTdHJpbmcgaWQpIHsKKwkJdGhpcy5pZCA9IGlkOworCX0KKwkKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9tZXNzYWdlL01lc3NhZ2VSZXF1ZXN0ZXJFdmVudC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL21lc3NhZ2UvTWVzc2FnZVJlcXVlc3RlckV2ZW50LmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjQ3YWEyMAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9tZXNzYWdlL01lc3NhZ2VSZXF1ZXN0ZXJFdmVudC5qYXZhCkBAIC0wLDAgKzEsMzAgQEAKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkubWVzc2FnZTsKKworaW1wb3J0IGphdmEudXRpbC5FdmVudE9iamVjdDsKKworcHVibGljIGNsYXNzIE1lc3NhZ2VSZXF1ZXN0ZXJFdmVudCBleHRlbmRzIEV2ZW50T2JqZWN0IHsKKwkvKioKKwkgKiAKKwkgKi8KKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSAtMzE2NjI2NDI0MTA4MTQ2MjQ3MEw7CisJcHJpdmF0ZSBTdHJpbmcgaWQ7CisJcHJpdmF0ZSBNZXNzYWdlRXZlbnQgZXZlbnREYXRhOworCisJcHVibGljIE1lc3NhZ2VSZXF1ZXN0ZXJFdmVudChPYmplY3Qgc291cmNlLCBTdHJpbmcgaWQsIE1lc3NhZ2VFdmVudCBldmVudERhdGEpIHsKKwkJc3VwZXIoc291cmNlKTsKKwkJdGhpcy5pZCA9IGlkOworCQl0aGlzLmV2ZW50RGF0YSA9IGV2ZW50RGF0YTsKKwl9CisKKwlwdWJsaWMgU3RyaW5nIGdldElkKCkgeworCQlyZXR1cm4gaWQ7CisJfQorCisJcHVibGljIE1lc3NhZ2VFdmVudCBnZXRFdmVudERhdGEoKSB7CisJCXJldHVybiBldmVudERhdGE7CisJfQorCisJcHVibGljIHZvaWQgc2V0RXZlbnREYXRhKE1lc3NhZ2VFdmVudCBldmVudERhdGEpIHsKKwkJdGhpcy5ldmVudERhdGEgPSBldmVudERhdGE7CisJfQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL21ldGFkYXRhL0lEU0xNZXRhZGF0YVNlcnZpY2UuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9tZXRhZGF0YS9JRFNMTWV0YWRhdGFTZXJ2aWNlLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTIzYmIwNgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9tZXRhZGF0YS9JRFNMTWV0YWRhdGFTZXJ2aWNlLmphdmEKQEAgLTAsMCArMSwyMTMgQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkubWV0YWRhdGE7CisKK2ltcG9ydCBqYXZhLm5ldC5VUkw7CitpbXBvcnQgamF2YS51dGlsLkxpc3Q7CitpbXBvcnQgamF2YS51dGlsLk1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuUHJvcGVydGllczsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmVtZi5lY29yZS5FQ2xhc3M7CitpbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmVjb3JlLkVPYmplY3Q7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5kc2wueHRleHQudHlwZXMuYnVuZGxlcy5CdW5kbGVTcGFjZVR5cGVQcm92aWRlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC5yZXNvdXJjZS5JRU9iamVjdERlc2NyaXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnV0aWwuUGFpcjsKKworLy8gVE9ETzogQXV0by1nZW5lcmF0ZWQgSmF2YWRvYworLyoqCisgKiBUaGUgSW50ZXJmYWNlIElEU0xNZXRhZGF0YVNlcnZpY2UuCisgKi8KK3B1YmxpYyBpbnRlcmZhY2UgSURTTE1ldGFkYXRhU2VydmljZSB7CisKKwkvKioKKwkgKiBUaGUgRW51bSBEU0xMaXRlcmFscyBhdm9pZHMgZGVwZW5kZW5jaWVzIHRvIHRoZSBjb25jcmV0ZSBEU0wKKwkgKiBpbXBsZW1lbnRhdGlvbnMuCisJICovCisJZW51bSBEU0xMaXRlcmFscyB7CisKKwkJLyoqIFRoZSBwZXJzcGVjdGl2ZSBsaXRlcmFsIHBsYWNlaG9sZGVyLiAqLworCQlQRVJTUEVDVElWRVMKKwl9CisKKwkvKioKKwkgKiBHZXRzIGRzbCBncmFtbWFyIGVsZW1lbnRzIGlkZW50aWZpZWQgYnkgYSBsaXRlcmFsIGVudW0uCisJICoKKwkgKiBAcGFyYW0gbGl0ZXJhbAorCSAqICAgICAgICAgICAgdGhlIGxpdGVyYWwKKwkgKiBAcmV0dXJuIGl0ZXJhdG9yIGZvciBkc2wgZ3JhbW1hciBlbGVtZW50cworCSAqLworCUBTdXBwcmVzc1dhcm5pbmdzKCJyYXd0eXBlcyIpCisJTGlzdDxQYWlyPiBnZXREc2xHcmFtbWFyRWxlbWVudE5hbWVzKElEU0xNZXRhZGF0YVNlcnZpY2UuRFNMTGl0ZXJhbHMgbGl0ZXJhbCk7CisKKwkvKioKKwkgKiBSZXR1cm5zIHRoZSBFT2JqZWN0IHRvIGJlIGNhc3RlZCB0byB0aGUgcmVxdWVzdGVkIG1vZGVsIGZvciB0aGUgZ2l2ZW4KKwkgKiBtb2RlbCBpZCBhbmQgRUNsYXNzLgorCSAqCisJICogQHBhcmFtIGlkCisJICogICAgICAgICAgICB0aGUgaWQKKwkgKiBAcGFyYW0gZWNsYXNzCisJICogICAgICAgICAgICB0aGUgZWNsYXNzCisJICogQHJldHVybiB0aGUgbWV0YWRhdGEKKwkgKi8KKwlFT2JqZWN0IGdldE1ldGFkYXRhKFN0cmluZyBpZCwgRUNsYXNzIGVjbGFzcyk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBhbGwgbWV0YWRhdGEgZGVzY3JpcHRpb25zLgorCSAqCisJICogQHBhcmFtIGVDbGFzcworCSAqICAgICAgICAgICAgdGhlIGUgY2xhc3MKKwkgKiBAcmV0dXJuIHRoZSBhbGwgZGVzY3JpcHRpb25zCisJICovCisJSXRlcmFibGU8SUVPYmplY3REZXNjcmlwdGlvbj4gZ2V0QWxsRGVzY3JpcHRpb25zKEVDbGFzcyBlQ2xhc3MpOworCisJLyoqCisJICogUmV0dXJucyB0aGUgZnVsbHkgcXVhbGlmaWVkIG5hbWUgZm9yIHRoZSBnaXZlbiBlT2JqZWN0LiBJZiB0aGUgbW9kZWwgaXMKKwkgKiBiYXNlZCBvbiBYdGV4dCwgdGhlbiB0aGUgcmV0dXJuZWQgZnFuIHNob3VsZCBiZSB1c2VkIGZyb20gdGhlCisJICogRU9iamVjdERlc2NyaXB0aW9uLgorCSAqIAorCSAqIFRPRE8gUmllZ2VsIC0gZW5zdXJlIHRoYXQgYWxsIERTTHMgZ2VuZXJhdGUgYSBwcm9wZXIgZnFuLiBGb3Igbm93IHRoZXkKKwkgKiBhcmUgbWlzc2luZyB0aGVpciBwYWNrYWdlIGluIHRoZSBGUU4uCisJICoKKwkgKiBAcGFyYW0gZU9iamVjdAorCSAqICAgICAgICAgICAgdGhlIEVPYmplY3QKKwkgKiBAcmV0dXJuIHRoZSBmdWxseSBxdWFsaWZpZWQgbmFtZQorCSAqLworCVN0cmluZyBnZXRGdWxseVF1YWxpZmllZE5hbWUoRU9iamVjdCBlT2JqZWN0KTsKKworCS8qKgorCSAqIFJldHVybnMgdGhlIGNsYXNzIG5hbWUgZm9yIHRoZSBnaXZlbiBlT2JqZWN0LiBLaW5kIHNwZWNpZmllcyB3aGljaCB0eXBlCisJICogb2YgY2xhc3Mgc2hvdWxkIGJlIHJldHVybmVkLiBUaGUgdHlwZXMgZGVwZW5kIG9uIHRoZWlyIHh0ZXh0IGluZmVycmVyLgorCSAqIFRoZXJlIG1heSBiZSBraW5kICJ1aSIsICJ0cmFuc2xhdG9yIiwgInNlcnZpY2UiLC4uLjxicj4KKwkgKiBJZiB5b3UgaGF2ZSBubyBpZGVhIHdoYXQgc2hvdWxkIGJlIHJldHVybmVkLCBqdXN0IGxlYXZlIHRoZSBraW5kCisJICogPGNvZGU+bnVsbDwvY29kZT4uCisJICoKKwkgKiBAcGFyYW0gZU9iamVjdAorCSAqICAgICAgICAgICAgdGhlIEVPYmplY3QKKwkgKiBAcGFyYW0ga2luZAorCSAqICAgICAgICAgICAgdGhlIGtpbmQgb2YgcmVxdWVzdGVkIGNsYXNzIHR5cGUuIERlcGVuZHMgb24gdGhlIHVuZGVybHlpbmcKKwkgKiAgICAgICAgICAgIG1vZGVsLiBMZWF2ZSBudWxsIGZvciBkZWZhdWx0LgorCSAqIEByZXR1cm4gdGhlIGNsYXNzIG5hbWUKKwkgKi8KKwlTdHJpbmcgZ2V0Q2xhc3NOYW1lKEVPYmplY3QgZU9iamVjdCwgU3RyaW5nIGtpbmQpOworCisJLyoqCisJICogUmV0dXJucyBhbGwgdGhlIGNsYXNzcGF0aCBVUkkgZm9yIGEgZ2l2ZW4gZXh0ZW5zaW9uLgorCSAqCisJICogQHBhcmFtIGNsYXNzTmFtZQorCSAqICAgICAgICAgICAgdGhlIGNsYXNzIG5hbWUKKwkgKiBAcGFyYW0gZXh0ZW5zaW9uCisJICogICAgICAgICAgICB0aGUgZXh0ZW5zaW9uCisJICogQHJldHVybiB0aGUgY2xhc3MgdXJpCisJICovCisJU3RyaW5nIGdldENsYXNzVVJJKFN0cmluZyBjbGFzc05hbWUsIFN0cmluZyBleHRlbnNpb24pOworCisJLyoqCisJICogUmV0dXJucyB0aGUgY2xhc3MgVVJJIGZvciB0aGUgZ2l2ZW4gZU9iamVjdCBhbmQga2luZC4gRm9yIGtpbmQgc2VlCisJICoge0BsaW5rICNnZXRDbGFzc05hbWUoRU9iamVjdCwgU3RyaW5nKX0uCisJICoKKwkgKiBAcGFyYW0gZU9iamVjdAorCSAqICAgICAgICAgICAgdGhlIGVPYmplY3QKKwkgKiBAcGFyYW0ga2luZAorCSAqICAgICAgICAgICAgdGhlIGtpbmQKKwkgKiBAcmV0dXJuIHRoZSBjbGFzcyBVUkkKKwkgKi8KKwlTdHJpbmcgZ2V0Q2xhc3NVUkkoRU9iamVjdCBlT2JqZWN0LCBTdHJpbmcga2luZCk7CisKKwkvKioKKwkgKiBHZXRzIGEgY2xhc3MgaW5zdGFuY2UgZm9yIHRoZSBnaXZlbiBlT2JqZWN0IGFuZCBleHRlbnNpb24uCisJICoKKwkgKiBAcGFyYW0gZU9iamVjdCB0aGUgZSBvYmplY3QKKwkgKiBAcGFyYW0gZXh0ZW5zaW9uIHRoZSBleHRlbnNpb24KKwkgKiBAcmV0dXJuIHRoZSBjbGFzcyBpbnN0YW5jZQorCSAqLworCU9iamVjdCBnZXRDbGFzc0luc3RhbmNlKEVPYmplY3QgZU9iamVjdCwgU3RyaW5nIGV4dGVuc2lvbik7CisJCisJLyoqCisJICogR2V0cyBhIHJlc291cmNlIFVSTCBmcm9tIHRoZSBidW5kbGUgb2YgdGhlIGdpdmVuIGV4dGVuc2lvbi4KKwkgKgorCSAqIEBwYXJhbSBlT2JqZWN0IHRoZSBlIG9iamVjdAorCSAqIEBwYXJhbSBkc2xFeHRlbnNpb24gdGhlIGRzbCBleHRlbnNpb24gZS5nLiByZXBvcnQKKwkgKiBAcGFyYW0gcmVzb3VyY2VFeHRlbnNpb24gdGhlIHJlc291cmNlIGV4dGVuc2lvbiBlLmcuIHJwdGRlc2lnbgorCSAqIEByZXR1cm4gdGhlIHJlc291cmNlIFVSTAorCSAqLworCVVSTCBnZXRSZXNvdXJjZVVSTChFT2JqZWN0IGVPYmplY3QsIFN0cmluZyBkc2xFeHRlbnNpb24sIFN0cmluZyByZXNvdXJjZUV4dGVuc2lvbik7CisJCisJLyoqCisJICogUmVzb2x2ZXMgdGhlIGdpdmVuIHByb3h5IHVzaW5nIHRoZSBpbnRlcm5hbCByZXNvdXJjZSBzZXQuCisJICogCisJICogQHBhcmFtIHByb3h5CisJICogICAgICAgICAgICB0aGUgcHJveHkgaW5zdGFuY2UKKwkgKiBAcmV0dXJuIHJlc29sdmVkIEVPYmplY3QKKwkgKi8KKwlFT2JqZWN0IHJlc29sdmUoRU9iamVjdCBwcm94eSk7CisKKwkvKioKKwkgKiBSZXR1cm5zIGFsbCByZXNvbHZlZCBFT2JqZWN0cyBwcm92aWRlZCBieQorCSAqIHtAbGluayAjZ2V0QWxsRGVzY3JpcHRpb25zKEVDbGFzcyl9LgorCSAqCisJICogQHBhcmFtIGVDbGFzcworCSAqICAgICAgICAgICAgdGhlIGUgY2xhc3MKKwkgKiBAcmV0dXJuIHRoZSBhbGwgRU9iamVjdHMKKwkgKi8KKwlJdGVyYWJsZTxFT2JqZWN0PiBnZXRBbGwoRUNsYXNzIGVDbGFzcyk7CisKKwkvKioKKwkgKiBUcmFuc2xhdGVzIGEgZnVsbHkgcXVhbGlmaWVkIGtleSBmb3IgdGhlIGdpdmVuIGxvY2FsZS4KKwkgKgorCSAqIEBwYXJhbSBsb2NhbGUKKwkgKiAgICAgICAgICAgIHRoZSBsb2NhbGUKKwkgKiBAcGFyYW0ga2V5CisJICogICAgICAgICAgICB0aGUga2V5CisJICogQHJldHVybiB0aGUgc3RyaW5nCisJICovCisJU3RyaW5nIHRyYW5zbGF0ZShTdHJpbmcgbG9jYWxlLCBTdHJpbmcga2V5KTsKKworCS8qKgorCSAqIEdldHMgYWxsIHRyYW5zbGF0aW9ucy4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHRyYW5zbGF0aW9ucyBmb3IgYWxsIGxhbmd1YWdlcworCSAqLworCU1hcDxTdHJpbmcsIFByb3BlcnRpZXM+IGdldFRyYW5zbGF0aW9ucygpOworCisJLyoqCisJICogR2V0cyB0aGUgYnVuZGxlIHNwYWNlIHR5cGUgcHJvdmlkZXIgZnJvbSBNZXRhZGF0YUJ1aWxkZXJTZXJ2aWNlLgorCSAqCisJICogQHJldHVybiB0aGUgdHlwZSBwcm92aWRlcgorCSAqLworCUBTdXBwcmVzc1dhcm5pbmdzKCJyZXN0cmljdGlvbiIpCisJQnVuZGxlU3BhY2VUeXBlUHJvdmlkZXIgZ2V0VHlwZVByb3ZpZGVyKCk7CisKKwkvKioKKwkgKiBSZXR1cm5zIGEgc2V0IHdpdGggYWxsIHN1YiB0eXBlcyBvZiB0aGUgZ2l2ZW4gdHlwZS4gVGhlIGtleSBob2xkcyB0aGUKKwkgKiBsb2NhbGl6ZWQgc2ltcGxlIG5hbWUgaWYgbG9jYWxlVGFnIGlzICE9IG51bGwgVGhlIHZhbHVlIGhvbGRzIHRoZQorCSAqIHF1YWxpZmllZCBuYW1lIG9mIHRoZSB0eXBlCisJICogCisJICogQHBhcmFtIGxvY2FsZVRhZworCSAqICAgICAgICAgICAgdGhlIGxvY2FsZSB0YWcKKwkgKiBAcGFyYW0gdHlwZU5hbWUKKwkgKiAgICAgICAgICAgIHRoZSB0eXBlIG5hbWUKKwkgKiBAcmV0dXJuIGFsbCBhcHBsaWNhYmxlIHR5cGUgbmFtZXMKKwkgKi8KKwlNYXA8U3RyaW5nLCBTdHJpbmc+IGdldEFsbFR5cGVOYW1lcyhTdHJpbmcgbG9jYWxlVGFnLCBTdHJpbmcgdHlwZU5hbWUpOworCisJLyoqCisJICogQ3JlYXRlcyBhbiBpbnN0YW5jZSBvZiB0aGUgZ2l2ZW4gcXVhbGlmaWVkIHR5cGUuCisJICoKKwkgKiBAcGFyYW0gdHlwZU5hbWUKKwkgKiAgICAgICAgICAgIHRoZSB0eXBlIG5hbWUKKwkgKiBAcmV0dXJuIHRoZSBjbGFzcworCSAqIEB0aHJvd3MgQ2xhc3NOb3RGb3VuZEV4Y2VwdGlvbgorCSAqICAgICAgICAgICAgIHRoZSBjbGFzcyBub3QgZm91bmQgZXhjZXB0aW9uCisJICovCisJQ2xhc3M8Pz4gY3JlYXRlVHlwZShTdHJpbmcgdHlwZU5hbWUpIHRocm93cyBDbGFzc05vdEZvdW5kRXhjZXB0aW9uOworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL29yZ2FuaXphdGlvbi9JT3JnYW5pemF0aW9uVmlld1BhcnRQcm92aWRlci5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL29yZ2FuaXphdGlvbi9JT3JnYW5pemF0aW9uVmlld1BhcnRQcm92aWRlci5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmEzNDlhMzgKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvb3JnYW5pemF0aW9uL0lPcmdhbml6YXRpb25WaWV3UGFydFByb3ZpZGVyLmphdmEKQEAgLTAsMCArMSwyOCBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5vcmdhbml6YXRpb247CisKKy8qKgorICogUmV0dXJucyB0aGUgVVJJIGZvciB0aGUgdmlld3BhcnQuIFVzZSAic2VydmljZS5yYW5raW5nOkludGVnZXI9MTAwMCIgYXMgT1NHaQorICogcHJvcGVydHkuCisgKi8KK3B1YmxpYyBpbnRlcmZhY2UgSU9yZ2FuaXphdGlvblZpZXdQYXJ0UHJvdmlkZXIgeworCisJLyoqCisJICogUmV0dXJucyB0aGUgVVJJIGZvciB0aGUgb3JnYW5pemF0aW9uIHZpZXcgcGFydC4KKwkgKiAKKwkgKiBAcmV0dXJuCisJICovCisJU3RyaW5nIGdldFZpZXdQYXJ0VVJJKCk7CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9wb3MvSVBPU1NlcnZpY2UuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9wb3MvSVBPU1NlcnZpY2UuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45OGZlYzI0Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3Bvcy9JUE9TU2VydmljZS5qYXZhCkBAIC0wLDAgKzEsODQgQEAKKy8qCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICBDb3B5cmlnaHQgKGMpIDIwMTEgLSAyMDE3IC0gTG9ldHogR21iSCAmIENvIEtHLCA2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55IAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiAgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogIEluaXRpYWwgY29udHJpYnV0aW9uOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgIExvZXR6IEdtYkggJiBDby4gS0cKKyAqIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnBvczsKKworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnN0YXRlbWFjaGluZS5JU3RhdGVNYWNoaW5lOworCisvKioKKyAqIFRoZSBJbnRlcmZhY2UgSVBPU1NlcnZpY2UgZXhwb3NlcyBjb21tdW5pY2F0aW9uIGxpbmsgdG8gcGF5bWVudCB0ZXJtaW5hbHMgdXNpbmcgWlZUIHByb3RvY29sCisgKi8KK3B1YmxpYyBpbnRlcmZhY2UgSVBPU1NlcnZpY2UgeworCQorCS8qKgorCSAqIFNldHMgdGhlIHN0YXRlbWFjaGluZS4KKwkgKgorCSAqIEBwYXJhbSBzdGF0ZW1hY2hpbmUgdGhlIG5ldyBzdGF0ZW1hY2hpbmUKKwkgKi8KKwl2b2lkIHNldFN0YXRlbWFjaGluZShJU3RhdGVNYWNoaW5lIHN0YXRlbWFjaGluZSk7CisJCisJLyoqCisJICogT3BlbiBaVlQgY2hhbm5lbC4KKwkgKgorCSAqIEBwYXJhbSBob3N0IHRoZSBob3N0CisJICogQHBhcmFtIHBvcnQgdGhlIHBvcnQKKwkgKiBAcmV0dXJuIHRydWUsIGlmIHN1Y2Nlc3NmdWwKKwkgKi8KKwlib29sZWFuIG9wZW5aVlRDaGFubmVsKFN0cmluZyBob3N0LCBpbnQgcG9ydCk7CisKKwkvKioKKwkgKiBDbG9zZSBaVlQgY2hhbm5lbC4KKwkgKi8KKwl2b2lkIGNsb3NlWlZUQ2hhbm5lbCgpOworCisJLyoqCisJICogU2VuZCBadnQgcmVnaXN0cmF0aW9uLgorCSAqCisJICogQHBhcmFtIHBhc3N3b3JkIHRoZSBwYXNzd29yZAorCSAqIEBwYXJhbSBjb25maWd1cmF0aW9uIHRoZSBjb25maWd1cmF0aW9uCisJICovCisJdm9pZCB6dnRSZWdpc3RyYXRpb24oU3RyaW5nIHBhc3N3b3JkLCBTdHJpbmcgY29uZmlndXJhdGlvbik7CisKKwkvKioKKwkgKiBTZW5kIFp2dCBhdXRob3JpemF0aW9uLgorCSAqCisJICogQHBhcmFtIGFtb3VudCB0aGUgYW1vdW50CisJICovCisJdm9pZCB6dnRBdXRob3JpemF0aW9uKERvdWJsZSBhbW91bnQpOworCisJLyoqCisJICogU2VuZCBadnQgYWNrbm93bGVkZ2UuCisJICovCisJdm9pZCB6dnRBY2tub3dsZWRnZSgpOworCQorCS8qKgorCSAqIFNlbmQgWnZ0IHJldmVyc2FsLgorCSAqCisJICogQHBhcmFtIHJlY2VpcHQgdGhlIHJlY2VpcHQKKwkgKi8KKwl2b2lkIHp2dFJldmVyc2FsKFN0cmluZyBwYXNzd29yZCwgU3RyaW5nIHJlY2VpcHQpOworCisJLyoqCisJICogR2V0cyB0aGUgenZ0IHJlc3BvbnNlLgorCSAqCisJICogQHJldHVybiB0aGUgenZ0IHJlc3BvbnNlCisJICovCisJU3RyaW5nIGdldFp2dFJlc3BvbnNlKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSB6dnQgdHJhbnNhY3Rpb25hbCBkYXRhLgorCSAqCisJICogQHJldHVybiB0aGUgenZ0IHRyYW5zYWN0aW9uYWwgZGF0YQorCSAqLworCUlaVlRUcmFuc2FjdGlvbkRhdGEgZ2V0WnZ0VHJhbnNhY3Rpb25EYXRhKCk7Cit9ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3Bvcy9JWlZUVHJhbnNhY3Rpb25EYXRhLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvcG9zL0laVlRUcmFuc2FjdGlvbkRhdGEuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iNzdjZjdmCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3Bvcy9JWlZUVHJhbnNhY3Rpb25EYXRhLmphdmEKQEAgLTAsMCArMSwzODMgQEAKKy8qCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICBDb3B5cmlnaHQgKGMpIDIwMTEgLSAyMDE3IC0gTG9ldHogR21iSCAmIENvIEtHLCA2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55IAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiAgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiAgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogIEluaXRpYWwgY29udHJpYnV0aW9uOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgIExvZXR6IEdtYkggJiBDby4gS0cKKyAqIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnBvczsKKworaW1wb3J0IGphdmEubmlvLkJ5dGVCdWZmZXI7CisKKy8qKgorICogVGhlIEludGVyZmFjZSBJWlZUVHJhbnNhY3Rpb25EYXRhLgorICovCitwdWJsaWMgaW50ZXJmYWNlIElaVlRUcmFuc2FjdGlvbkRhdGEgeworCQorCS8qKgorCSAqIFRoZSBFbnVtIFBheW1lbnRUeXBlLgorCSAqLworCXN0YXRpYyBlbnVtIFBheW1lbnRUeXBlIHsKKwkJCisJCS8qKiBvZmZsaW5lIG1vZGUgKi8KKwkJT0ZGTElORSwgCisJCS8qKiBjYXJkIGlzIGNoZWNrZWQgd2l0aG91dCBhdXRob3JpemF0aW9uICovCisJCUNBUkRDSEVDS0VEX05PQVVUSE9SSVpBVElPTiwgCisJCS8qKiBvbmxpbmUgbW9kZSAqLworCQlPTkxJTkUsIAorCQkvKiogcGluIG1vZGUgKi8KKwkJUElOCisJfTsKKworCS8qKgorCSAqIFBhcnNlcyB0aGUuCisJICoKKwkgKiBAcGFyYW0gYnVmZmVyIHRoZSBidWZmZXIKKwkgKiBAcGFyYW0gcG9zaXRpb24gdGhlIHBvc2l0aW9uCisJICogQHBhcmFtIGxlbmd0aCB0aGUgbGVuZ3RoCisJICogQHJldHVybiB0aGUgaW50CisJICovCisJaW50IHBhcnNlKEJ5dGVCdWZmZXIgYnVmZmVyLCBpbnQgcG9zaXRpb24sIGludCBsZW5ndGgpOworCisJLyoqCisJICogR2V0cyB0aGUgYW1vdW50LgorCSAqCisJICogQHJldHVybiB0aGUgYW1vdW50CisJICovCisJZG91YmxlIGdldEFtb3VudCgpOworCisJLyoqCisJICogU2V0cyB0aGUgYW1vdW50LgorCSAqCisJICogQHBhcmFtIGFtb3VudCB0aGUgbmV3IGFtb3VudAorCSAqLworCXZvaWQgc2V0QW1vdW50KGRvdWJsZSBhbW91bnQpOworCisJLyoqCisJICogR2V0cyB0aGUgdHJhY2UgbnVtYmVyLgorCSAqCisJICogQHJldHVybiB0aGUgdHJhY2UgbnVtYmVyCisJICovCisJU3RyaW5nIGdldFRyYWNlTnVtYmVyKCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSB0cmFjZSBudW1iZXIuCisJICoKKwkgKiBAcGFyYW0gdHJhY2VOdW1iZXIgdGhlIG5ldyB0cmFjZSBudW1iZXIKKwkgKi8KKwl2b2lkIHNldFRyYWNlTnVtYmVyKFN0cmluZyB0cmFjZU51bWJlcik7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBvcmlnaW5hbCB0cmFjZSBudW1iZXIuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBvcmlnaW5hbCB0cmFjZSBudW1iZXIKKwkgKi8KKwlTdHJpbmcgZ2V0T3JpZ2luYWxUcmFjZU51bWJlcigpOworCisJLyoqCisJICogU2V0cyB0aGUgb3JpZ2luYWwgdHJhY2UgbnVtYmVyLgorCSAqCisJICogQHBhcmFtIG9yaWdpbmFsVHJhY2VOdW1iZXIgdGhlIG5ldyBvcmlnaW5hbCB0cmFjZSBudW1iZXIKKwkgKi8KKwl2b2lkIHNldE9yaWdpbmFsVHJhY2VOdW1iZXIoU3RyaW5nIG9yaWdpbmFsVHJhY2VOdW1iZXIpOworCisJLyoqCisJICogR2V0cyB0aGUgY2FyZCBzZXF1ZW5jZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGNhcmQgc2VxdWVuY2UKKwkgKi8KKwlpbnQgZ2V0Q2FyZFNlcXVlbmNlKCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSBjYXJkIHNlcXVlbmNlLgorCSAqCisJICogQHBhcmFtIGNhcmRTZXF1ZW5jZSB0aGUgbmV3IGNhcmQgc2VxdWVuY2UKKwkgKi8KKwl2b2lkIHNldENhcmRTZXF1ZW5jZShpbnQgY2FyZFNlcXVlbmNlKTsKKworCS8qKgorCSAqIEdldHMgdGhlIHBheW1lbnQgdHlwZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHBheW1lbnQgdHlwZQorCSAqLworCVBheW1lbnRUeXBlIGdldFBheW1lbnRUeXBlKCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSBwYXltZW50IHR5cGUuCisJICoKKwkgKiBAcGFyYW0gcGF5bWVudFR5cGUgdGhlIG5ldyBwYXltZW50IHR5cGUKKwkgKi8KKwl2b2lkIHNldFBheW1lbnRUeXBlKFBheW1lbnRUeXBlIHBheW1lbnRUeXBlKTsKKworCS8qKgorCSAqIEdldHMgdGhlIHBhbiBlZmlkLgorCSAqCisJICogQHJldHVybiB0aGUgcGFuIGVmaWQKKwkgKi8KKwlTdHJpbmcgZ2V0UGFuX2VmaWQoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIHBhbiBlZmlkLgorCSAqCisJICogQHBhcmFtIHBhbl9lZmlkIHRoZSBuZXcgcGFuIGVmaWQKKwkgKi8KKwl2b2lkIHNldFBhbl9lZmlkKFN0cmluZyBwYW5fZWZpZCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSB0ZXJtaW5hbCBpZC4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHRlcm1pbmFsIGlkCisJICovCisJU3RyaW5nIGdldFRlcm1pbmFsSWQoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIHRlcm1pbmFsIGlkLgorCSAqCisJICogQHBhcmFtIHRlcm1pbmFsSWQgdGhlIG5ldyB0ZXJtaW5hbCBpZAorCSAqLworCXZvaWQgc2V0VGVybWluYWxJZChTdHJpbmcgdGVybWluYWxJZCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBhdXRob3JpemF0aW9uLgorCSAqCisJICogQHJldHVybiB0aGUgYXV0aG9yaXphdGlvbgorCSAqLworCVN0cmluZyBnZXRBdXRob3JpemF0aW9uKCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSBhdXRob3JpemF0aW9uLgorCSAqCisJICogQHBhcmFtIGF1dGhvcml6YXRpb24gdGhlIG5ldyBhdXRob3JpemF0aW9uCisJICovCisJdm9pZCBzZXRBdXRob3JpemF0aW9uKFN0cmluZyBhdXRob3JpemF0aW9uKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGN1cnJlbmN5LgorCSAqCisJICogQHJldHVybiB0aGUgY3VycmVuY3kKKwkgKi8KKwlpbnQgZ2V0Q3VycmVuY3koKTsKKworCS8qKgorCSAqIFNldHMgdGhlIGN1cnJlbmN5LgorCSAqCisJICogQHBhcmFtIGN1cnJlbmN5IHRoZSBuZXcgY3VycmVuY3kKKwkgKi8KKwl2b2lkIHNldEN1cnJlbmN5KGludCBjdXJyZW5jeSk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBibG9ja2VkIGdyb3Vwcy4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGJsb2NrZWQgZ3JvdXBzCisJICovCisJU3RyaW5nIGdldEJsb2NrZWRHcm91cHMoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIGJsb2NrZWQgZ3JvdXBzLgorCSAqCisJICogQHBhcmFtIGJsb2NrZWRHcm91cHMgdGhlIG5ldyBibG9ja2VkIGdyb3VwcworCSAqLworCXZvaWQgc2V0QmxvY2tlZEdyb3VwcyhTdHJpbmcgYmxvY2tlZEdyb3Vwcyk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSByZWNlaXB0LgorCSAqCisJICogQHJldHVybiB0aGUgcmVjZWlwdAorCSAqLworCVN0cmluZyBnZXRSZWNlaXB0KCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSByZWNlaXB0LgorCSAqCisJICogQHBhcmFtIHJlY2VpcHQgdGhlIG5ldyByZWNlaXB0CisJICovCisJdm9pZCBzZXRSZWNlaXB0KFN0cmluZyByZWNlaXB0KTsKKworCS8qKgorCSAqIEdldHMgdGhlIGNhcmQgdHlwZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGNhcmQgdHlwZQorCSAqLworCWludCBnZXRDYXJkVHlwZSgpOworCisJLyoqCisJICogU2V0cyB0aGUgY2FyZCB0eXBlLgorCSAqCisJICogQHBhcmFtIGNhcmRUeXBlIHRoZSBuZXcgY2FyZCB0eXBlCisJICovCisJdm9pZCBzZXRDYXJkVHlwZShpbnQgY2FyZFR5cGUpOworCisJLyoqCisJICogR2V0cyB0aGUgY2FyZCB0eXBlIElELgorCSAqCisJICogQHJldHVybiB0aGUgY2FyZCB0eXBlIElECisJICovCisJaW50IGdldENhcmRUeXBlSUQoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIGNhcmQgdHlwZSBJRC4KKwkgKgorCSAqIEBwYXJhbSBjYXJkVHlwZUlEIHRoZSBuZXcgY2FyZCB0eXBlIElECisJICovCisJdm9pZCBzZXRDYXJkVHlwZUlEKGludCBjYXJkVHlwZUlEKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGdlbGQga2FydGUuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBnZWxkIGthcnRlCisJICovCisJU3RyaW5nIGdldEdlbGRLYXJ0ZSgpOworCisJLyoqCisJICogU2V0cyB0aGUgZ2VsZCBrYXJ0ZS4KKwkgKgorCSAqIEBwYXJhbSBnZWxkS2FydGUgdGhlIG5ldyBnZWxkIGthcnRlCisJICovCisJdm9pZCBzZXRHZWxkS2FydGUoU3RyaW5nIGdlbGRLYXJ0ZSk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBhdXRob3JpemF0aW9uIHBhcmFtZXRlci4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGF1dGhvcml6YXRpb24gcGFyYW1ldGVyCisJICovCisJU3RyaW5nIGdldEF1dGhvcml6YXRpb25QYXJhbWV0ZXIoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIGF1dGhvcml6YXRpb24gcGFyYW1ldGVyLgorCSAqCisJICogQHBhcmFtIGF1dGhvcml6YXRpb25QYXJhbWV0ZXIgdGhlIG5ldyBhdXRob3JpemF0aW9uIHBhcmFtZXRlcgorCSAqLworCXZvaWQgc2V0QXV0aG9yaXphdGlvblBhcmFtZXRlcihTdHJpbmcgYXV0aG9yaXphdGlvblBhcmFtZXRlcik7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBjb250cmFjdCBudW1iZXIuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBjb250cmFjdCBudW1iZXIKKwkgKi8KKwlTdHJpbmcgZ2V0Q29udHJhY3ROdW1iZXIoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIGNvbnRyYWN0IG51bWJlci4KKwkgKgorCSAqIEBwYXJhbSBjb250cmFjdE51bWJlciB0aGUgbmV3IGNvbnRyYWN0IG51bWJlcgorCSAqLworCXZvaWQgc2V0Q29udHJhY3ROdW1iZXIoU3RyaW5nIGNvbnRyYWN0TnVtYmVyKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGFkZGl0aW9uYWwgdGV4dC4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGFkZGl0aW9uYWwgdGV4dAorCSAqLworCVN0cmluZyBnZXRBZGRpdGlvbmFsVGV4dCgpOworCisJLyoqCisJICogU2V0cyB0aGUgYWRkaXRpb25hbCB0ZXh0LgorCSAqCisJICogQHBhcmFtIGFkZGl0aW9uYWxUZXh0IHRoZSBuZXcgYWRkaXRpb25hbCB0ZXh0CisJICovCisJdm9pZCBzZXRBZGRpdGlvbmFsVGV4dChTdHJpbmcgYWRkaXRpb25hbFRleHQpOworCisJLyoqCisJICogR2V0cyB0aGUgcmVzdWx0IGNvZGUgQVMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSByZXN1bHQgY29kZSBBUworCSAqLworCVN0cmluZyBnZXRSZXN1bHRDb2RlQVMoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIHJlc3VsdCBjb2RlIEFTLgorCSAqCisJICogQHBhcmFtIHJlc3VsdENvZGVBUyB0aGUgbmV3IHJlc3VsdCBjb2RlIEFTCisJICovCisJdm9pZCBzZXRSZXN1bHRDb2RlQVMoU3RyaW5nIHJlc3VsdENvZGVBUyk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSB0dXJub3ZlciBudW1iZXIuCisJICoKKwkgKiBAcmV0dXJuIHRoZSB0dXJub3ZlciBudW1iZXIKKwkgKi8KKwlTdHJpbmcgZ2V0VHVybm92ZXJOdW1iZXIoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIHR1cm5vdmVyIG51bWJlci4KKwkgKgorCSAqIEBwYXJhbSB0dXJub3Zlck51bWJlciB0aGUgbmV3IHR1cm5vdmVyIG51bWJlcgorCSAqLworCXZvaWQgc2V0VHVybm92ZXJOdW1iZXIoU3RyaW5nIHR1cm5vdmVyTnVtYmVyKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGNhcmQgbmFtZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGNhcmQgbmFtZQorCSAqLworCVN0cmluZyBnZXRDYXJkTmFtZSgpOworCisJLyoqCisJICogU2V0cyB0aGUgY2FyZCBuYW1lLgorCSAqCisJICogQHBhcmFtIGNhcmROYW1lIHRoZSBuZXcgY2FyZCBuYW1lCisJICovCisJdm9pZCBzZXRDYXJkTmFtZShTdHJpbmcgY2FyZE5hbWUpOworCisJLyoqCisJICogR2V0cyB0aGUgdGx2LgorCSAqCisJICogQHJldHVybiB0aGUgdGx2CisJICovCisJU3RyaW5nIGdldFRsdigpOworCisJLyoqCisJICogU2V0cyB0aGUgdGx2LgorCSAqCisJICogQHBhcmFtIHRsdiB0aGUgbmV3IHRsdgorCSAqLworCXZvaWQgc2V0VGx2KFN0cmluZyB0bHYpOworCisJLyoqCisJICogR2V0cyB0aGUgdHJhbnNhY3Rpb24gdGltZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHRyYW5zYWN0aW9uIHRpbWUKKwkgKi8KKwlTdHJpbmcgZ2V0VHJhbnNhY3Rpb25UaW1lKCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSB0cmFuc2FjdGlvbiB0aW1lLgorCSAqCisJICogQHBhcmFtIHRpbWUgdGhlIG5ldyB0cmFuc2FjdGlvbiB0aW1lCisJICovCisJdm9pZCBzZXRUcmFuc2FjdGlvblRpbWUoU3RyaW5nIHRpbWUpOworCisJLyoqCisJICogR2V0cyB0aGUgdHJhbnNhY3Rpb24gZGF0ZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHRyYW5zYWN0aW9uIGRhdGUKKwkgKi8KKwlTdHJpbmcgZ2V0VHJhbnNhY3Rpb25EYXRlKCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSB0cmFuc2FjdGlvbiBkYXRlLgorCSAqCisJICogQHBhcmFtIGRhdGUgdGhlIG5ldyB0cmFuc2FjdGlvbiBkYXRlCisJICovCisJdm9pZCBzZXRUcmFuc2FjdGlvbkRhdGUoU3RyaW5nIGRhdGUpOworCisJLyoqCisJICogR2V0cyB0aGUgZXhwaXJ5IGRhdGUuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBleHBpcnkgZGF0ZQorCSAqLworCVN0cmluZyBnZXRFeHBpcnkoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIGV4cGlyeSBkYXRlLgorCSAqCisJICogQHBhcmFtIGV4cGlyeSB0aGUgbmV3IGV4cGlyeSBkYXRlCisJICovCisJdm9pZCBzZXRFeHBpcnkoU3RyaW5nIGV4cGlyeSk7Cit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvcmVwb3J0L0lSZXBvcnRQcm92aWRlci5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3JlcG9ydC9JUmVwb3J0UHJvdmlkZXIuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xZDE5MjQzCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3JlcG9ydC9JUmVwb3J0UHJvdmlkZXIuamF2YQpAQCAtMCwwICsxLDc2IEBACitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnJlcG9ydDsKKworaW1wb3J0IGphdmEuaW8uSW5wdXRTdHJlYW07CitpbXBvcnQgamF2YS51dGlsLk1hcDsKKworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmRhdGFtYXJ0LklEYXRhTWFydDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5kYXRhbWFydC5JRGF0YW1hcnRGaWx0ZXJHZW5lcmF0b3I7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkubWV0YWRhdGEuSURTTE1ldGFkYXRhU2VydmljZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS50aGVtZXMuSVRoZW1lUmVzb3VyY2VTZXJ2aWNlOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXIuSVVzZXI7CisKK3B1YmxpYyBpbnRlcmZhY2UgSVJlcG9ydFByb3ZpZGVyIHsKKwlwdWJsaWMgZmluYWwgc3RhdGljIFN0cmluZyBBUFBDT05URVhUX1JFUE9SVCA9ICJBcHBDb250ZXh0X1JlcG9ydCI7CisJcHVibGljIGZpbmFsIHN0YXRpYyBTdHJpbmcgQVBQQ09OVEVYVF9USEVNRVJFU09VUkNFU0VSVklDRSA9ICJUaGVtZVJlc291cmNlU2VydmljZV9SZXBvcnQiOworCXB1YmxpYyBmaW5hbCBzdGF0aWMgU3RyaW5nIEFQUENPTlRFWFRfRFNMTUVUQURBVEFTRVJWSUNFID0gIkRTTE1ldGFkYXRhU2VydmljZV9SZXBvcnQiOworCXB1YmxpYyBmaW5hbCBzdGF0aWMgU3RyaW5nIEFQUENPTlRFWFRfVVNFUiA9ICJVc2VyX1JlcG9ydCI7CisJcHVibGljIGZpbmFsIHN0YXRpYyBTdHJpbmcgQVBQQ09OVEVYVF9EQVRBTUFSVElOU1RBTkNFID0gIkRhdGFtYXJ0SW5zdGFuY2VfUmVwb3J0IjsKKwlwdWJsaWMgZmluYWwgc3RhdGljIFN0cmluZyBBUFBDT05URVhUX0ZJTFRFUk1BUCA9ICJGaWx0ZXJNYXBfUmVwb3J0IjsKKwlwdWJsaWMgZmluYWwgc3RhdGljIFN0cmluZyBBUFBDT05URVhUX1BST1BFUlRZTE9PS1VQID0gIlByb3BlcnR5TG9va3VwX1JlcG9ydCI7CisKKwlwdWJsaWMgZW51bSBSZW5kZXJpbmcgeworCQlQREZfRklMRShmYWxzZSwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIGZhbHNlKSwgUERGX1NUUkVBTShmYWxzZSwgdHJ1ZSwKKwkJCQlmYWxzZSwgdHJ1ZSwgZmFsc2UpLAorCQkvKiogQHNlZSB7QGxpbmsgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9mb3J1bXMvaW5kZXgucGhwL3QvMjA0MDg1L30gKi8KKwkJUERGX1BSSU5UX1NUUkVBTShmYWxzZSwgdHJ1ZSwgZmFsc2UsIHRydWUsIHRydWUpLCBIVE1MX0ZJTEUodHJ1ZSwKKwkJCQlmYWxzZSwgdHJ1ZSwgZmFsc2UsIGZhbHNlKSwgSFRNTF9TVFJFQU0odHJ1ZSwgZmFsc2UsIGZhbHNlLAorCQkJCXRydWUsIGZhbHNlKTsKKworCQlwdWJsaWMgYm9vbGVhbiBhc0h0bWwoKSB7CisJCQlyZXR1cm4gZkFzSHRtbDsKKwkJfQorCisJCXB1YmxpYyBib29sZWFuIGFzUGRmKCkgeworCQkJcmV0dXJuIGZBc1BkZjsKKwkJfQorCisJCXB1YmxpYyBib29sZWFuIGFzRmlsZSgpIHsKKwkJCXJldHVybiBmQXNGaWxlOworCQl9CisKKwkJcHVibGljIGJvb2xlYW4gYXNTdHJlYW0oKSB7CisJCQlyZXR1cm4gZkFzU3RyZWFtOworCQl9CisKKwkJcHVibGljIGJvb2xlYW4gZm9yUHJpbnRpbmcoKSB7CisJCQlyZXR1cm4gZkZvclByaW50aW5nOworCQl9CisKKwkJcHJpdmF0ZSBmaW5hbCBib29sZWFuIGZBc0h0bWw7CisJCXByaXZhdGUgZmluYWwgYm9vbGVhbiBmQXNQZGY7CisJCXByaXZhdGUgZmluYWwgYm9vbGVhbiBmQXNGaWxlOworCQlwcml2YXRlIGZpbmFsIGJvb2xlYW4gZkFzU3RyZWFtOworCQlwcml2YXRlIGZpbmFsIGJvb2xlYW4gZkZvclByaW50aW5nOworCisJCVJlbmRlcmluZyhib29sZWFuIGFzSHRtbCwgYm9vbGVhbiBhc1BkZiwgYm9vbGVhbiBhc0ZpbGUsCisJCQkJYm9vbGVhbiBhc1N0cmVhbSwgYm9vbGVhbiBmb3JQcmludGluZykgeworCQkJZkFzSHRtbCA9IGFzSHRtbDsKKwkJCWZBc1BkZiA9IGFzUGRmOworCQkJZkFzRmlsZSA9IGFzRmlsZTsKKwkJCWZBc1N0cmVhbSA9IGFzU3RyZWFtOworCQkJZkZvclByaW50aW5nID0gZm9yUHJpbnRpbmc7CisJCX0KKwl9CisKKwl2b2lkIHByaW50UmVwb3J0QXNQZGYoU3RyaW5nIHJlcG9ydElkLCBJVXNlciB1c2VyLAorCQkJSURTTE1ldGFkYXRhU2VydmljZSBkc2xNZXRhZGF0YVNlcnZpY2UsIE1hcDxTdHJpbmcsIFN0cmluZz4gZmlsdGVyTWFwKTsKKworCUlucHV0U3RyZWFtIGdldChTdHJpbmcgcmVwb3J0SWQsIElVc2VyIHVzZXIsCisJCQlJRFNMTWV0YWRhdGFTZXJ2aWNlIGRzbE1ldGFkYXRhU2VydmljZSwgTWFwPFN0cmluZywgU3RyaW5nPiBmaWx0ZXJNYXApOworCisJSW5wdXRTdHJlYW0gZ2V0KFN0cmluZyByZXBvcnRJZCwgSVVzZXIgdXNlciwKKwkJCUlEU0xNZXRhZGF0YVNlcnZpY2UgZHNsTWV0YWRhdGFTZXJ2aWNlLCBNYXA8U3RyaW5nLCBTdHJpbmc+IGZpbHRlck1hcCwKKwkJCVJlbmRlcmluZyByZW5kZXJlciwgSVRoZW1lUmVzb3VyY2VTZXJ2aWNlIHRoZW1lUmVzb3VyY2VTZXJ2aWNlLAorCQkJU3RyaW5nIG91dHB1dFBhdGgpOworCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvc3RhdGVtYWNoaW5lL0lEYXRhUHJvdmlkZXIuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9zdGF0ZW1hY2hpbmUvSURhdGFQcm92aWRlci5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQ3YzY4MzcKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvc3RhdGVtYWNoaW5lL0lEYXRhUHJvdmlkZXIuamF2YQpAQCAtMCwwICsxLDE5IEBACitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnN0YXRlbWFjaGluZTsKKworaW1wb3J0IGphdmEudXRpbC5TdGFjazsKKworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLmNvbW1vbi5kYXRhdHlwZXMuSUR0bzsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5kdG8ubGliLnNlcnZpY2VzLlF1ZXJ5OworCitwdWJsaWMgaW50ZXJmYWNlIElEYXRhUHJvdmlkZXIgeworCXZvaWQgaW5pdERhdGFzb3VyY2UoU3RyaW5nIGR0b05hbWUpOworCXB1YmxpYyBpbnRlcmZhY2UgUHJvdmlkZXIgZXh0ZW5kcyBJU3RhdGVNYWNoaW5lUGFydGljaXBhbnQgeworCQlCb29sZWFuIGZpbmQoUHJvdmlkZXIgbGlzdGVuZXIsIFN0cmluZyBkdG9OYW1lLCBRdWVyeSBxdWVyeSk7CisJCUJvb2xlYW4gZmluZChQcm92aWRlciBsaXN0ZW5lciwgU3RyaW5nIGR0b05hbWUsIFN0cmluZyBmaWVsZG5hbWUsIE9iamVjdCBzZWFyY2gpOworCQlCb29sZWFuIG9wZXJhdGlvbihQcm92aWRlciBsaXN0ZW5lciwgU3RyaW5nIG5hbWUsIFN0YWNrPE9iamVjdD4gcGFyYW1ldGVyKTsKKwkJdm9pZCBhZGRUbyhQcm92aWRlciBsaXN0ZW5lciwgU3RyaW5nIGR0b05hbWUsIFN0cmluZyBsaXN0TmFtZSwgSUR0byBkdG8pOworCQl2b2lkIHJlbW92ZUZyb20oUHJvdmlkZXIgbGlzdGVuZXIsIFN0cmluZyBkdG9OYW1lLCBTdHJpbmcgbGlzdE5hbWUsIElEdG8gZHRvKTsKKwkJdm9pZCB1cGRhdGUoUHJvdmlkZXIgbGlzdGVuZXIsIFN0cmluZyBkdG9OYW1lLCBJRHRvIGR0byk7CisJCXZvaWQgZGVsZXRlKFByb3ZpZGVyIGxpc3RlbmVyLCBTdHJpbmcgZHRvTmFtZSwgSUR0byBkdG8pOworCX0KK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS9zdGF0ZW1hY2hpbmUvSUV2ZW50U291cmNlLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvc3RhdGVtYWNoaW5lL0lFdmVudFNvdXJjZS5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM0MGUxNzkKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvc3RhdGVtYWNoaW5lL0lFdmVudFNvdXJjZS5qYXZhCkBAIC0wLDAgKzEsMTEgQEAKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuc3RhdGVtYWNoaW5lOworCitwdWJsaWMgaW50ZXJmYWNlIElFdmVudFNvdXJjZSB7CisJcHVibGljIGludGVyZmFjZSBFbmFibGVyIGV4dGVuZHMgSVN0YXRlTWFjaGluZVBhcnRpY2lwYW50IHsKKwkJdm9pZCBlbmFibGUoRW5hYmxlciBsaXN0ZW5lciwgU3RyaW5nIGlkLCBCb29sZWFuIGVuYWJsZWQpOworCQl2b2lkIGFwcGVuZChFbmFibGVyIGxpc3RlbmVyLCBTdHJpbmcgaWQsIFN0cmluZyBrZXkpOworCQl2b2lkIHJlbW92ZShFbmFibGVyIGxpc3RlbmVyLCBTdHJpbmcgaWQsIGludCBwb3MpOworCQl2b2lkIGNhcHRpb24oRW5hYmxlciBsaXN0ZW5lciwgU3RyaW5nIGlkLCBTdHJpbmcgdmFsdWUpOworCQl2b2lkIGltYWdlKEVuYWJsZXIgbGlzdGVuZXIsIFN0cmluZyBpZCwgU3RyaW5nIGltYWdlTmFtZSk7CisJfQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3N0YXRlbWFjaGluZS9JUGVyaXBoZXJhbC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3N0YXRlbWFjaGluZS9JUGVyaXBoZXJhbC5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNiMGEwNzQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvc3RhdGVtYWNoaW5lL0lQZXJpcGhlcmFsLmphdmEKQEAgLTAsMCArMSw4IEBACitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnN0YXRlbWFjaGluZTsKKworcHVibGljIGludGVyZmFjZSBJUGVyaXBoZXJhbHsKKwl2b2lkIGluaXREZXZpY2VzKCk7CisJdm9pZCByZWxlYXNlRGV2aWNlcygpOworCXB1YmxpYyBpbnRlcmZhY2UgQ29tbWFuZCBleHRlbmRzIElTdGF0ZU1hY2hpbmVQYXJ0aWNpcGFudCB7CisJfQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3N0YXRlbWFjaGluZS9JU3RhdGVNYWNoaW5lLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvc3RhdGVtYWNoaW5lL0lTdGF0ZU1hY2hpbmUuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41NjdkNzk3Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3N0YXRlbWFjaGluZS9JU3RhdGVNYWNoaW5lLmphdmEKQEAgLTAsMCArMSwxNTkgQEAKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuc3RhdGVtYWNoaW5lOworCitpbXBvcnQgamF2YS5uaW8uY2hhbm5lbHMuU2VsZWN0YWJsZUNoYW5uZWw7CitpbXBvcnQgamF2YS51dGlsLkxvY2FsZTsKK2ltcG9ydCBqYXZhLnV0aWwuU2V0OworaW1wb3J0IGphdmEudXRpbC5TdGFjazsKKworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLmNvbW1vbi5kYXRhdHlwZXMuSUR0bzsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5kdG8ubGliLnNlcnZpY2VzLlF1ZXJ5OworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLm1lc3NhZ2UuTWVzc2FnZUV2ZW50OworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLm1lc3NhZ2UuTWVzc2FnZUV2ZW50LkV2ZW50VHlwZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5tZXRhZGF0YS5JRFNMTWV0YWRhdGFTZXJ2aWNlOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnJlcG9ydC5JUmVwb3J0UHJvdmlkZXI7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudGhlbWVzLklUaGVtZVJlc291cmNlU2VydmljZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS51c2VyLklVc2VyOworaW1wb3J0IG9yZy5qb2RhLnRpbWUuRGF0ZVRpbWU7CisKK3B1YmxpYyBpbnRlcmZhY2UgSVN0YXRlTWFjaGluZSB7CisJY2xhc3MgRGF0YSB7CisJCXB1YmxpYyBTdHJpbmcgbmFtZTsKKwkJcHVibGljIERvdWJsZSB2YWx1ZTsKKwkJcHVibGljIEJvb2xlYW4gc3RhdGU7CisJCXB1YmxpYyBPYmplY3Qgb2JqZWN0OworCX07CisKKwlTdHJpbmcgZ2V0SVBBZGRyZXNzKCk7CisKKwlEYXRlVGltZSBnZXROb3coKTsKKworCXZvaWQgcHJvY2Vzc0V2ZW50KElTdGF0ZU1hY2hpbmUgc3RhdGVtYWNoaW5lLCBNZXNzYWdlRXZlbnQgZXZlbnQpOworCisJdm9pZCByZWdpc3RlckVuYWJsZXIoSUV2ZW50U291cmNlLkVuYWJsZXIgbGlzdGVuZXIpOworCisJdm9pZCB1bnJlZ2lzdGVyRW5hYmxlcihJRXZlbnRTb3VyY2UuRW5hYmxlciBsaXN0ZW5lcik7CisKKwl2b2lkIHJlZ2lzdGVyRGF0YVByb3ZpZGVyKElEYXRhUHJvdmlkZXIuUHJvdmlkZXIgbGlzdGVuZXIpOworCisJdm9pZCB1bnJlZ2lzdGVyRGF0YVByb3ZpZGVyKElEYXRhUHJvdmlkZXIuUHJvdmlkZXIgbGlzdGVuZXIpOworCisJdm9pZCBzdGFydCgpOworCisJdm9pZCBlbmFibGUoU3RyaW5nIGlkLCBCb29sZWFuIGVuYWJsZSk7CisKKwlPYmplY3QgZ2V0KFN0cmluZyBpZCk7CisKKwl2b2lkIHNldChTdHJpbmcgaWQsIE9iamVjdCBjb250ZW50KTsKKworCXZvaWQgY2xlYXIoU3RyaW5nIGlkKTsKKworCXZvaWQgYXBwZW5kKFN0cmluZyBpZCwgU3RyaW5nIGtleSk7CisKKwl2b2lkIHJlbW92ZShTdHJpbmcgaWQsIGludCBwb3MpOworCisJdm9pZCBjYXB0aW9uKFN0cmluZyBpZCwgU3RyaW5nIHZhbHVlKTsKKworCXZvaWQgaW1hZ2UoU3RyaW5nIGlkLCBTdHJpbmcgaW1hZ2VOYW1lKTsKKwkKKwl2b2lkIGFkZERhdGFQcm92aWRlcihJRGF0YVByb3ZpZGVyLlByb3ZpZGVyIGxpc3RlbmVyKTsKKworCXZvaWQgcmVtb3ZlRGF0YVByb3ZpZGVyKElEYXRhUHJvdmlkZXIuUHJvdmlkZXIgbGlzdGVuZXIpOworCisJdm9pZCByZWdpc3RlclBlcmlwaGVyYWwoSVBlcmlwaGVyYWwuQ29tbWFuZCBsaXN0ZW5lcik7CisKKwl2b2lkIHVucmVnaXN0ZXJQZXJpcGhlcmFsKElQZXJpcGhlcmFsLkNvbW1hbmQgbGlzdGVuZXIpOworCisJQm9vbGVhbiBmaW5kKFN0cmluZyBkdG9OYW1lLCBTdHJpbmcgZmllbGROYW1lLCBPYmplY3Qgc2VhcmNoKTsKKworCUJvb2xlYW4gZmluZChTdHJpbmcgZHRvTmFtZSwgUXVlcnkgcXVlcnkpOworCQorCXZvaWQgYWRkVG8oU3RyaW5nIGR0b05hbWUsIFN0cmluZyBsaXN0TmFtZSwgSUR0byBkdG8pOworCisJdm9pZCByZW1vdmVGcm9tKFN0cmluZyBkdG9OYW1lLCBTdHJpbmcgbGlzdE5hbWUsIElEdG8gZHRvKTsKKwkKKwl2b2lkIHVwZGF0ZShTdHJpbmcgZHRvTmFtZSk7CisKKwl2b2lkIGRlbGV0ZShTdHJpbmcgZHRvTmFtZSk7CisKKwlCb29sZWFuIG9wZXJhdGlvbihTdHJpbmcgbmFtZSwgU3RhY2s8T2JqZWN0PiBwYXJhbWV0ZXIpOworCisJU3RyaW5nIGdldFVzZXJBZ2VudEluZm8oKTsKKworCUJvb2xlYW4gaXNUb3VjaERldmljZSgpOworCisJaW50IGdldFNjZWVuV2lkdGgoKTsKKworCWludCBnZXRTY3JlZW5IZWlnaHQoKTsKKworCUxvY2FsZSBnZXRCcm93c2VyTG9jYWxlKCk7CisKKwlCb29sZWFuIGlzSHR0cHMoKTsKKworCXZvaWQgc2NoZWR1bGUoSVN0YXRlTWFjaGluZSBzdGF0ZW1hY2hpbmUsIGxvbmcgbWlsbGlzZWNvbmRzLAorCQkJTWVzc2FnZUV2ZW50IGV2ZW50KTsKKworCURvdWJsZSBwYXJzZURvdWJsZShTdHJpbmcgZG91YmxlU3RyKTsKKworCVN0cmluZyBmb3JtYXREb3VibGUoRG91YmxlIHZhbHVlLCBpbnQgbGVuZ3RoLCBpbnQgcHJlY2lzaW9uKTsKKworCXZvaWQgc2V0VXNlcihJVXNlciB1c2VyKTsKKworCUlVc2VyIGdldFVzZXIoKTsKKworCVN0cmluZyBnZXRVc2VyTmFtZSgpOworCQorCVN0cmluZyBnZXRVc2VyUGFzc3dvcmQoKTsKKworCVN0cmluZyBnZXRVc2VyRW1haWwoKTsKKwkKKwlTdHJpbmcgZ2V0VXNlclBvc2l0aW9uKCk7CisJCisJU3RyaW5nIGdldFVzZXJQcmludFNlcnZpY2UoKTsKKwkKKwl2b2lkIHNldExvY2FsZShMb2NhbGUgbG9jYWxlKTsKKworCUxvY2FsZSBnZXRMb2NhbGUoKTsKKworCVN0YWNrPE9iamVjdD4gZ2V0UGFyYW1ldGVycygpOworCisJdm9pZCBzZXREc2xNZXRhZGF0YVNlcnZpY2UoSURTTE1ldGFkYXRhU2VydmljZSBkc2xNZXRhZGF0YVNlcnZpY2UpOworCisJSURTTE1ldGFkYXRhU2VydmljZSBnZXREc2xNZXRhZGF0YVNlcnZpY2UoKTsKKwkKKwl2b2lkIHNldFRoZW1lUmVzb3VyY2VTZXJ2aWNlKElUaGVtZVJlc291cmNlU2VydmljZSB0aGVtZVJlc291cmNlU2VydmljZSk7CisJCisJSVRoZW1lUmVzb3VyY2VTZXJ2aWNlIGdldFRoZW1lUmVzb3VyY2VTZXJ2aWNlKCk7CisKKwlTdHJpbmcgZ2V0VHJhbnNsYXRpb24oU3RyaW5nIHRva2VuKTsKKworCXZvaWQgY2xvc2VNZXNzYWdlKFN0cmluZyBtZXNzYWdlSWQpOworCQorCXZvaWQgc2V0UmVwb3J0UHJvdmlkZXIoSVJlcG9ydFByb3ZpZGVyIHJlcG9ydHByb3ZpZGVyKTsKKwkKKwlJUmVwb3J0UHJvdmlkZXIgZ2V0UmVwb3J0UHJvdmlkZXIoKTsKKworCXZvaWQgb3Blbk1lc3NhZ2UoU3RyaW5nIG1lc3NhZ2VJZCk7CisKKwl2b2lkIG9wZW5NZXNzYWdlKFN0cmluZyBtZXNzYWdlSWQsIGJvb2xlYW4gb2tCdXR0b24pOworCQorCXZvaWQgb3BlblF1ZXN0aW9uKFN0cmluZyBtZXNzYWdlSWQsIEV2ZW50VHlwZSB0eXBlLCBTdHJpbmcgeWVzRXZlbnQsIFN0cmluZyBub0V2ZW50LCBTdHJpbmcgY2FuY2VsRXZlbnQpOworCisJdm9pZCBkaXNwYXRjaE1lc3NhZ2VzKE1lc3NhZ2VFdmVudCBldmVudCk7CisJCisJdm9pZCBjbGVhclBhcmFtZXRlcnMoKTsKKwkKKwlPYmplY3QgZ2V0U3RvcmFnZShTdHJpbmcga2V5LCBTdHJpbmcgYXR0cmlidXRlKTsKKwkKKwlTZXQ8U3RyaW5nPiBnZXRTdG9yYWdlQXR0cmlidXRlcyhTdHJpbmcga2V5KTsKKworCXZvaWQgcHV0U3RvcmFnZShTdHJpbmcga2V5LCBTdHJpbmcgYXR0cmlidXRlLCBPYmplY3QgY29udGVudCk7CisJCisJdm9pZCBvcGVuQ2hhbm5lbChTZWxlY3RhYmxlQ2hhbm5lbCBjaGFubmVsKTsKKwkKKwlTZWxlY3RhYmxlQ2hhbm5lbCBnZXRDaGFubmVsKCk7CisJCisJdm9pZCBjbG9zZUNoYW5uZWwoKTsKKworCVN0cmluZyBnZXRMYXN0VHJpZ2dlcigpOworCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvc3RhdGVtYWNoaW5lL0lTdGF0ZU1hY2hpbmVQYXJ0aWNpcGFudC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3N0YXRlbWFjaGluZS9JU3RhdGVNYWNoaW5lUGFydGljaXBhbnQuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mNzQ2ZTk5Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3N0YXRlbWFjaGluZS9JU3RhdGVNYWNoaW5lUGFydGljaXBhbnQuamF2YQpAQCAtMCwwICsxLDMwIEBACitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnN0YXRlbWFjaGluZTsKKworaW1wb3J0IGphdmEubGFuZy5yZWZsZWN0Lk1ldGhvZDsKK2ltcG9ydCBqYXZhLnV0aWwuTG9jYWxlOworCitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24uY29udGV4dC5JVmlld0NvbnRleHQ7CisKK3B1YmxpYyBpbnRlcmZhY2UgSVN0YXRlTWFjaGluZVBhcnRpY2lwYW50IHsKKwl2b2lkIHNldFN0YXRlbWFjaGluZShJU3RhdGVNYWNoaW5lIHN0YXRlbWFjaGluZSk7CisKKwlJU3RhdGVNYWNoaW5lIGdldFN0YXRlbWFjaGluZSgpOworCisJdm9pZCBzZXRWaWV3Q29udGV4dChJVmlld0NvbnRleHQgdmlld0NvbnRleHQpOworCisJdm9pZCBpbml0KCk7CisKKwl2b2lkIHNldExvY2FsZShMb2NhbGUgbG9jYWxlKTsKKworCU1ldGhvZCBnZXR0ZXIoT2JqZWN0IGxpc3RlbmVyLCBTdHJpbmcgaWQpOworCisJTWV0aG9kIHNldHRlcihPYmplY3QgbGlzdGVuZXIsIFN0cmluZyBpZCwgQ2xhc3M8Pz4gcGFyYW1ldGVyKTsKKworCUNsYXNzPD8+IGdldFJldHVyblR5cGUoT2JqZWN0IG9iaiwgU3RyaW5nIGlkKTsKKworCXZvaWQgc2V0KE9iamVjdCBvYmosIFN0cmluZyBpZCwgT2JqZWN0IGNvbnRlbnQpOworCisJT2JqZWN0IGdldChPYmplY3Qgb2JqLCBTdHJpbmcgaWQpOworCisJdm9pZCBjbGVhcihPYmplY3Qgb2JqLCBTdHJpbmcgaWQpOworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3RoZW1lcy9JVGhlbWVSZXNvdXJjZVNlcnZpY2UuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS90aGVtZXMvSVRoZW1lUmVzb3VyY2VTZXJ2aWNlLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDExMGE0YwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS90aGVtZXMvSVRoZW1lUmVzb3VyY2VTZXJ2aWNlLmphdmEKQEAgLTAsMCArMSw2OCBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS50aGVtZXM7CisKK2ltcG9ydCBqYXZhLmlvLklucHV0U3RyZWFtOworCitpbXBvcnQgY29tLnZhYWRpbi5zZXJ2ZXIuUmVzb3VyY2U7CisKK3B1YmxpYyBpbnRlcmZhY2UgSVRoZW1lUmVzb3VyY2VTZXJ2aWNlIHsKKwkKKwkvKiogYWxsIGF2YWlsYWJsZSB0aGVtZSByZXNvdXJjZSB0eXBlcyAqLworCXN0YXRpYyBwdWJsaWMgZW51bSBUaGVtZVJlc291cmNlVHlwZSB7CisJCS8qKiBhbnkgImJpZyIgaW1hZ2VzIGxpa2UgYmFja2dyb3VuZCBpbWFnZXMgKi8KKwkJSU1BR0UsIAorCQkvKiogYW55ICJzbWFsbCIgaWNvbnMsIG1vc3RseSAxNngxNiBweCAqLworCQlJQ09OLAorCQkvKiogZmxhZyBpY29uLCBtb3N0bHkgMTZ4MTYgcHggKi8KKwkJRkxBRywKKwl9CisJCisJLyoqCisJICogUmVzZXRzIHRoZSBiYXNlIHBhdGhzIG9mIHRoZSB0aGVtZSByZXNvdXJjZSAgCisJICovCisJdm9pZCByZXNldCgpOworCS8qKgorCSAqIEBwYXJhbSB0aGVtZVJlc291cmNlVHlwZQorCSAqIEByZXR1cm4gdGhlIGZpbGUgZXh0ZW5zaW9uIGRlZmluZWQgZm9yIHRoZSB0aGVtZSByZXNvdXJjZSB0eXBlCisJICovCisJU3RyaW5nIGdldFRoZW1lUmVzb3VyY2VUeXBlRXh0ZW5zaW9uKFRoZW1lUmVzb3VyY2VUeXBlIHRoZW1lUmVzb3VyY2VUeXBlKTsKKwkKKwkvKioKKwkgKiBAcGFyYW0gdGhlbWVSZXNvdXJjZVR5cGUKKwkgKiBAcmV0dXJuIHRoZSBwYXRoIGRlZmluZWQgZm9yIHRoZSB0aGVtZSByZXNvdXJjZSB0eXBlCisJICovCisJU3RyaW5nIGdldFRoZW1lUmVzb3VyY2VUeXBlUGF0aChUaGVtZVJlc291cmNlVHlwZSB0aGVtZVJlc291cmNlVHlwZSk7CisJCisJLyoqCisJICogQHBhcmFtIHJlc291cmNlSUQKKwkgKiBAcGFyYW0gdGhlbWVSZXNvdXJjZVR5cGUKKwkgKiBAcmV0dXJuIHRoZSBmdWxsIHF1YWxpZmllZCB1cmkgZm9yIHRoZSByZXNvdXJjZSBpZCBvZiB0aGUgdGhlbWUgcmVzb3VyY2UgdHlwZQorCSAqLworCVN0cmluZyBnZXRUaGVtZVVSSShTdHJpbmcgcmVzb3VyY2VJRCwgVGhlbWVSZXNvdXJjZVR5cGUgdGhlbWVSZXNvdXJjZVR5cGUpOworCQorCS8qKgorCSAqIEBwYXJhbSByZXNvdXJjZUlECisJICogQHBhcmFtIHRoZW1lUmVzb3VyY2VUeXBlCisJICogQHJldHVybiB0aGUgcmVzb3VyY2UgZm9yIHRoZSByZXNvdXJjZSBpZCBvZiB0aGUgdGhlbWUgcmVzb3VyY2UgdHlwZQorCSAqLworCVJlc291cmNlIGdldFRoZW1lUmVzb3VyY2UoU3RyaW5nIHJlc291cmNlSUQsIFRoZW1lUmVzb3VyY2VUeXBlIHRoZW1lUmVzb3VyY2VUeXBlKTsKKwkKKwkvKioKKwkgKiBHZXRzIHRoZSB0aGVtZSByZXNvdXJjZSBpbnB1dCBzdHJlYW0uCisJICoKKwkgKiBAcGFyYW0gcmVzb3VyY2VVUkwgdGhlIHJlc291cmNlIFVSTAorCSAqIEByZXR1cm4gdGhlIHRoZW1lIHJlc291cmNlIGlucHV0IHN0cmVhbQorCSAqLworCUlucHV0U3RyZWFtIGdldFRoZW1lUmVzb3VyY2VJbnB1dFN0cmVhbShTdHJpbmcgcmVzb3VyY2VVUkwpOworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXIvSVVzZXIuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyL0lVc2VyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGIzNGY5YwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyL0lVc2VyLmphdmEKQEAgLTAsMCArMSwxOTkgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS51c2VyOworCitpbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247CitpbXBvcnQgamF2YS51dGlsLkxvY2FsZTsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmU0LnVpLm1vZGVsLmFwcGxpY2F0aW9uLk1BcHBsaWNhdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5jdXN0b21maWVsZHMuSUJsb2JVcGxvYWRDb21wb25lbnQ7CisKKy8qKgorICogRXZlcnkgdXNlciBvYmplY3QgbmVlZHMgdG8gaW1wbGVtZW50IHRoaXMgaW50ZXJmYWNlLgorICovCitwdWJsaWMgaW50ZXJmYWNlIElVc2VyIHsKKwkvLyB0byBhdm9pZCBkZXBlbmRlbmN5IHRvIHB1YmxpY2FwaQorCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIHVzZXJDbGFzcyA9ICJ1c2VyQ2xhc3MiOworCS8qKgorCSAqIFNldHMgdGhlIGFwcGxpY2F0aW9uLgorCSAqCisJICogQHBhcmFtIGFwcGxpY2F0aW9uCisJICogICAgICAgICAgICB0aGUgbmV3IGFwcGxpY2F0aW9uCisJICovCisJdm9pZCBzZXRBcHBsaWNhdGlvbihNQXBwbGljYXRpb24gYXBwbGljYXRpb24pOworCisJLyoqCisJICogUmV0dXJucyB0aGUgdXNlciBuYW1lLgorCSAqIAorCSAqIEByZXR1cm4KKwkgKi8KKwlTdHJpbmcgZ2V0VXNlck5hbWUoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGxheW91dGluZyBzdHJhdGVneS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGxheW91dGluZyBzdHJhdGVneQorCSAqLworCVN0cmluZyBnZXRMYXlvdXRpbmdTdHJhdGVneSgpOworCisJLyoqCisJICogR2V0cyB0aGUgZm9jdXNpbmcgc3RyYXRlZ3kuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBmb2N1c2luZyBzdHJhdGVneQorCSAqLworCVN0cmluZyBnZXRGb2N1c2luZ1N0cmF0ZWd5KCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSB0aGVtZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHRoZW1lCisJICovCisJU3RyaW5nIGdldFRoZW1lKCk7CisJCisJLyoqCisJICogR2V0cyB0aGUgUHJpbnQgU2VydmljZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHByaW50IHNlcnZpY2UgbmFtZQorCSAqLworCVN0cmluZyBnZXRQcmludFNlcnZpY2UoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIHVzZXIgbmFtZS4KKwkgKgorCSAqIEBwYXJhbSB1c2VyTmFtZQorCSAqICAgICAgICAgICAgdGhlIG5ldyB1c2VyIG5hbWUKKwkgKi8KKwl2b2lkIHNldFVzZXJOYW1lKFN0cmluZyB1c2VyTmFtZSk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBpZC4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGlkCisJICovCisJU3RyaW5nIGdldElkKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBwb3NpdGlvbi4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHBvc2l0aW9uCisJICovCisJU3RyaW5nIGdldFBvc2l0aW9uKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBleHRyYSBwYXNzd29yZC4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGV4dHJhIHBhc3N3b3JkCisJICovCisJU3RyaW5nIGdldEV4dHJhUGFzc3dvcmQoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIHN1cGVydmlzb3IuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBzdXBlcnZpc29yCisJICovCisJYm9vbGVhbiBpc1N1cGVydmlzb3IoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIHBlcnNwZWN0aXZlIGlkLgorCSAqCisJICogQHJldHVybiB0aGUgcGVyc3BlY3RpdmUgaWQKKwkgKi8KKwlTdHJpbmcgZ2V0UGVyc3BlY3RpdmUoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGVtYWlsLgorCSAqCisJICogQHJldHVybiB0aGUgZW1haWwKKwkgKi8KKwlTdHJpbmcgZ2V0RW1haWwoKTsKKwkKKwkvKioKKwkgKiBHZXRzIHRoZSBibG9iIHVwbG9hZCBjb21wb25lbnQuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBibG9iIHVwbG9hZCBjb21wb25lbnQKKwkgKi8KKwlJQmxvYlVwbG9hZENvbXBvbmVudCBnZXRCbG9iVXBsb2FkQ29tcG9uZW50KCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSByb2xlcy4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHJvbGVzCisJICovCisJQ29sbGVjdGlvbjxTdHJpbmc+IGdldFJvbGVzKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBsb2NhbGUuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBsb2NhbGUKKwkgKi8KKwlMb2NhbGUgZ2V0TG9jYWxlKCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSBsb2NhbGUuCisJICoKKwkgKiBAcGFyYW0gbG9jYWxlCisJICogICAgICAgICAgICB0aGUgbmV3IGxvY2FsZQorCSAqLworCXZvaWQgc2V0TG9jYWxlKExvY2FsZSBsb2NhbGUpOworCisJLyoqCisJICogU2V0cyB0aGUgcHJpbnQgc2VydmljZSBuYW1lLgorCSAqCisJICogQHBhcmFtIHByaW50IHNlcnZpY2UKKwkgKiAgICAgICAgICAgIHRoZSBuZXcgcHJpbnQgc2VydmljZQorCSAqLworCXZvaWQgc2V0UHJpbnRTZXJ2aWNlKFN0cmluZyBwcmludFNlcnZpY2UpOworCisJLyoqCisJICogQWRkcyBhIGxvY2FsZSBsaXN0ZW5lciB0byB0aGUgc2VydmljZS4KKwkgKgorCSAqIEBwYXJhbSBsaXN0ZW5lcgorCSAqICAgICAgICAgICAgdGhlIGxpc3RlbmVyCisJICovCisJdm9pZCBhZGRVc2VyTG9jYWxlTGlzdGVuZXIoVXNlckxvY2FsZUxpc3RlbmVyIGxpc3RlbmVyKTsKKworCS8qKgorCSAqIFJlbW92ZXMgdGhlIGdpdmVuIGxvY2FsZSBsaXN0ZW5lciBmcm9tIHRoZSBzZXJ2aWNlLgorCSAqCisJICogQHBhcmFtIGxpc3RlbmVyCisJICogICAgICAgICAgICB0aGUgbGlzdGVuZXIKKwkgKi8KKwl2b2lkIHJlbW92ZVVzZXJMb2NhbGVMaXN0ZW5lcihVc2VyTG9jYWxlTGlzdGVuZXIgbGlzdGVuZXIpOworCisJLyoqCisJICogTm90aWZpZXMgdGhlIGxpc3RlbmVyIGFib3V0IHRoZSBjaGFuZ2VkIGxvY2FsZS4KKwkgKgorCSAqIEBwYXJhbSBsb2NhbGUKKwkgKiAgICAgICAgICAgIHRoZSBsb2NhbGUKKwkgKi8KKwl2b2lkIG5vdGlmeVVzZXJMb2NhbGVDaGFuZ2VkKExvY2FsZSBsb2NhbGUpOworCisJLyoqCisJICogVGhlIGxpc3RlbmVyIGludGVyZmFjZSBmb3IgcmVjZWl2aW5nIGxvY2FsZSBldmVudHMuIFRoZSBjbGFzcyB0aGF0IGlzCisJICogaW50ZXJlc3RlZCBpbiBwcm9jZXNzaW5nIGEgbG9jYWxlIGV2ZW50IGltcGxlbWVudHMgdGhpcyBpbnRlcmZhY2UsIGFuZAorCSAqIHRoZSBvYmplY3QgY3JlYXRlZCB3aXRoIHRoYXQgY2xhc3MgaXMgcmVnaXN0ZXJlZCB3aXRoIGEgY29tcG9uZW50IHVzaW5nCisJICogdGhlIGNvbXBvbmVudCdzIDxjb2RlPmFkZExvY2FsZUxpc3RlbmVyPC9jb2RlPiBtZXRob2QuIFdoZW4gdGhlIHVzZXIncworCSAqIGxvY2FsZSBjaGFuZ2UgZXZlbnQgb2NjdXJzLCB0aGF0IG9iamVjdCdzIGFwcHJvcHJpYXRlIG1ldGhvZCBpcyBpbnZva2VkLgorCSAqCisJICovCisJaW50ZXJmYWNlIFVzZXJMb2NhbGVMaXN0ZW5lciB7CisKKwkJLyoqCisJCSAqIE5vdGlmaWVzIHRoZSBsaXN0ZW5lciBhYm91dCBhIGxvY2FsZSBjaGFuZ2UuCisJCSAqCisJCSAqIEBwYXJhbSBsb2NhbGUKKwkJICogICAgICAgICAgICB0aGUgbG9jYWxlCisJCSAqLworCQl2b2lkIGxvY2FsZUNoYW5nZWQoTG9jYWxlIGxvY2FsZSk7CisKKwl9CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0Fic3RyYWN0QXV0aG9yaXphdGlvbi5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvQWJzdHJhY3RBdXRob3JpemF0aW9uLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzdmYzc5ZAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0Fic3RyYWN0QXV0aG9yaXphdGlvbi5qYXZhCkBAIC0wLDAgKzEsNTkxIEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3M7CisKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaFNldDsKK2ltcG9ydCBqYXZhLnV0aWwuU2V0OworCisvLyBUT0RPOiBBdXRvLWdlbmVyYXRlZCBKYXZhZG9jCisvKioKKyAqIFRoZSBDbGFzcyBBQXV0aG9yaXphdGlvbi4KKyAqLworcHVibGljIGFic3RyYWN0IGNsYXNzIEFic3RyYWN0QXV0aG9yaXphdGlvbiB7CisKKwkvKiogVGhlIGF1dGhvcml6YXRpb24gZ3JvdXBzLiAqLworCXByaXZhdGUgZmluYWwgSGFzaE1hcDxTdHJpbmcsIEFic3RyYWN0Um9sZUF1dGhvcml6YXRpb25Hcm91cD4gZkF1dGhvcml6YXRpb25Hcm91cHM7CisKKwkvKioKKwkgKiBJbnN0YW50aWF0ZXMgYSBuZXcgYSBhdXRob3JpemF0aW9uLgorCSAqCisJICogQHBhcmFtIGF1dGhvcml6YXRpb25Hcm91cHMKKwkgKiAgICAgICAgICAgIHRoZSBhdXRob3JpemF0aW9uIGdyb3VwcworCSAqLworCXByb3RlY3RlZCBBYnN0cmFjdEF1dGhvcml6YXRpb24oQWJzdHJhY3RSb2xlQXV0aG9yaXphdGlvbkdyb3VwLi4uIGF1dGhvcml6YXRpb25Hcm91cHMpIHsKKwkJZkF1dGhvcml6YXRpb25Hcm91cHMgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIEFic3RyYWN0Um9sZUF1dGhvcml6YXRpb25Hcm91cD4oKTsKKwkJZm9yIChBYnN0cmFjdFJvbGVBdXRob3JpemF0aW9uR3JvdXAgYXV0aG9yaXphdGlvbkdyb3VwIDogYXV0aG9yaXphdGlvbkdyb3VwcykgeworCQkJZkF1dGhvcml6YXRpb25Hcm91cHMucHV0KGF1dGhvcml6YXRpb25Hcm91cC5nZXRSb2xlTmFtZSgpLCBhdXRob3JpemF0aW9uR3JvdXApOworCQl9CisJfQorCisJLyoqCisJICogR2V0cyB0aGUgYXV0aG9yaXphdGlvbiBncm91cCBuYW1lLgorCSAqCisJICogQHJldHVybiB0aGUgYXV0aG9yaXphdGlvbiBncm91cCBuYW1lCisJICovCisJZmluYWwgcHVibGljIFN0cmluZyBnZXRBdXRob3JpemF0aW9uR3JvdXBOYW1lKCkgeworCQlyZXR1cm4gdGhpcy5nZXRDbGFzcygpLmdldFNpbXBsZU5hbWUoKTsKKwl9CisKKwkvKioKKwkgKiBBZGRzIHRoZSByb2xlIGF1dGhvcml6YXRpb24gZ3JvdXAuCisJICoKKwkgKiBAcGFyYW0gcm9sZU5hbWUKKwkgKiAgICAgICAgICAgIHRoZSByb2xlIG5hbWUKKwkgKiBAcGFyYW0gZ3JvdXAKKwkgKiAgICAgICAgICAgIHRoZSBncm91cAorCSAqLworCWZpbmFsIHB1YmxpYyB2b2lkIGFkZFJvbGVBdXRob3JpemF0aW9uR3JvdXAoU3RyaW5nIHJvbGVOYW1lLCBBYnN0cmFjdFJvbGVBdXRob3JpemF0aW9uR3JvdXAgZ3JvdXApIHsKKwkJZkF1dGhvcml6YXRpb25Hcm91cHMucHV0KHJvbGVOYW1lLCBncm91cCk7CisJfQorCisJLyoqCisJICogR2V0cyB0aGUgcm9sZSBhdXRob3JpemF0aW9uIGdyb3VwLgorCSAqCisJICogQHBhcmFtIHJvbGUKKwkgKiAgICAgICAgICAgIHRoZSByb2xlCisJICogQHJldHVybiB0aGUgcm9sZSBhdXRob3JpemF0aW9uIGdyb3VwCisJICovCisJZmluYWwgcHVibGljIEFic3RyYWN0Um9sZUF1dGhvcml6YXRpb25Hcm91cCBnZXRSb2xlQXV0aG9yaXphdGlvbkdyb3VwKFN0cmluZyByb2xlKSB7CisJCXJldHVybiBmQXV0aG9yaXphdGlvbkdyb3Vwcy5nZXQocm9sZSk7CisJfQorCisJLyoqCisJICogR2V0cyB0aGUgYXV0aG9yaXphdGlvbiBncm91cHMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBhdXRob3JpemF0aW9uIGdyb3VwcworCSAqLworCWZpbmFsIHB1YmxpYyBIYXNoTWFwPFN0cmluZywgQWJzdHJhY3RSb2xlQXV0aG9yaXphdGlvbkdyb3VwPiBnZXRBdXRob3JpemF0aW9uR3JvdXBzKCkgeworCQlyZXR1cm4gdGhpcy5mQXV0aG9yaXphdGlvbkdyb3VwczsKKwl9CisKKwkvKioKKwkgKiBUaGUgQ2xhc3MgUGVybWlzc2lvbi4KKwkgKi8KKwlwdWJsaWMgc3RhdGljIGNsYXNzIFBlcm1pc3Npb24geworCisJCS8qKiBUaGUgQ29uc3RhbnQgQU5ZLiAqLworCQlwcml2YXRlIGZpbmFsIHN0YXRpYyBTdHJpbmcgQU5ZID0gIioiOworCisJCS8qKiBUaGUgQ29uc3RhbnQgU0VQQVJBVE9SLiAqLworCQlwcml2YXRlIGZpbmFsIHN0YXRpYyBTdHJpbmcgU0VQQVJBVE9SID0gIjoiOworCisJCS8qKiBUaGUgdHlwZS4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBUeXBlIGZUeXBlOworCisJCS8qKiBUaGUgZ3JvdXAuICovCisJCXByaXZhdGUgZmluYWwgR3JvdXAgZkdyb3VwOworCisJCS8qKiBUaGUgY2xhc3MuICovCisJCXByaXZhdGUgZmluYWwgU3RyaW5nIGZDbGFzczsKKworCQkvKiogVGhlIGF0dHJpYnV0ZS4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBTdHJpbmcgZkF0dHJpYnV0ZTsKKworCQkvKiogVGhlIGFjdGlvbi4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBBY3Rpb24gZkFjdGlvbjsKKworCQkvKioKKwkJICogRm9yIGJsaXAgcHJvY2VzcyBzdGFydC4KKwkJICoKKwkJICogQHBhcmFtIGJsaXBQcm9jZXNzCisJCSAqICAgICAgICAgICAgdGhlIGJsaXAgcHJvY2VzcworCQkgKiBAcGFyYW0gYWN0aW9uCisJCSAqICAgICAgICAgICAgdGhlIGFjdGlvbgorCQkgKiBAcmV0dXJuIHRoZSBwZXJtaXNzaW9uCisJCSAqLworCQlwdWJsaWMgc3RhdGljIFBlcm1pc3Npb24gZm9yQmxpcFByb2Nlc3MoU3RyaW5nIGJsaXBQcm9jZXNzLCBBY3Rpb24gYWN0aW9uKSB7CisJCQlyZXR1cm4gbmV3IFBlcm1pc3Npb24oR3JvdXAuYmxpcFByb2Nlc3MsIGJsaXBQcm9jZXNzLCBhY3Rpb24pOworCQl9CisKKwkJLyoqCisJCSAqIEZvciBibGlwIHVzZXIgdGFzayBleGVjdXRlLgorCQkgKgorCQkgKiBAcGFyYW0gYmxpcFVzZXJUYXNrCisJCSAqICAgICAgICAgICAgdGhlIGJsaXAgdXNlciB0YXNrCisJCSAqIEBwYXJhbSBhY3Rpb24KKwkJICogICAgICAgICAgICB0aGUgYWN0aW9uCisJCSAqIEByZXR1cm4gdGhlIHBlcm1pc3Npb24KKwkJICovCisJCXB1YmxpYyBzdGF0aWMgUGVybWlzc2lvbiBmb3JCbGlwVXNlclRhc2soU3RyaW5nIGJsaXBVc2VyVGFzaywgQWN0aW9uIGFjdGlvbikgeworCQkJcmV0dXJuIG5ldyBQZXJtaXNzaW9uKEdyb3VwLmJsaXBVc2VyVGFzaywgYmxpcFVzZXJUYXNrLCBhY3Rpb24pOworCQl9CisKKwkJLyoqCisJCSAqIEZvciBlbnRpdHkuCisJCSAqCisJCSAqIEBwYXJhbSBlbnRpdHkKKwkJICogICAgICAgICAgICB0aGUgZW50aXR5CisJCSAqIEBwYXJhbSBhY3Rpb24KKwkJICogICAgICAgICAgICB0aGUgYWN0aW9uCisJCSAqIEByZXR1cm4gdGhlIHBlcm1pc3Npb24KKwkJICovCisJCXB1YmxpYyBzdGF0aWMgUGVybWlzc2lvbiBmb3JFbnRpdHkoU3RyaW5nIGVudGl0eSwgQWN0aW9uIGFjdGlvbikgeworCQkJcmV0dXJuIG5ldyBQZXJtaXNzaW9uKEdyb3VwLmVudGl0eSwgZW50aXR5LCBhY3Rpb24pOworCQl9CisKKwkJLyoqCisJCSAqIEZvciBlbnRpdHkgcHJvcGVydHkuCisJCSAqCisJCSAqIEBwYXJhbSBlbnRpdHkKKwkJICogICAgICAgICAgICB0aGUgZW50aXR5CisJCSAqIEBwYXJhbSBwcm9wZXJ0eQorCQkgKiAgICAgICAgICAgIHRoZSBwcm9wZXJ0eQorCQkgKiBAcGFyYW0gYWN0aW9uCisJCSAqICAgICAgICAgICAgdGhlIGFjdGlvbgorCQkgKiBAcmV0dXJuIHRoZSBwZXJtaXNzaW9uCisJCSAqLworCQlwdWJsaWMgc3RhdGljIFBlcm1pc3Npb24gZm9yRW50aXR5UHJvcGVydHkoU3RyaW5nIGVudGl0eSwgU3RyaW5nIHByb3BlcnR5LCBBY3Rpb24gYWN0aW9uKSB7CisJCQlyZXR1cm4gbmV3IFBlcm1pc3Npb24oR3JvdXAuZW50aXR5LCBlbnRpdHksIHByb3BlcnR5LCBhY3Rpb24pOworCQl9CisKKwkJLyoqCisJCSAqIEZvciBkdG8uCisJCSAqCisJCSAqIEBwYXJhbSBkdG8KKwkJICogICAgICAgICAgICB0aGUgZHRvCisJCSAqIEBwYXJhbSBhY3Rpb24KKwkJICogICAgICAgICAgICB0aGUgYWN0aW9uCisJCSAqIEByZXR1cm4gdGhlIHBlcm1pc3Npb24KKwkJICovCisJCXB1YmxpYyBzdGF0aWMgUGVybWlzc2lvbiBmb3JEdG8oU3RyaW5nIGR0bywgQWN0aW9uIGFjdGlvbikgeworCQkJcmV0dXJuIG5ldyBQZXJtaXNzaW9uKEdyb3VwLmR0bywgZHRvLCBhY3Rpb24pOworCQl9CisKKwkJLyoqCisJCSAqIEZvciBkdG8gcHJvcGVydHkuCisJCSAqCisJCSAqIEBwYXJhbSBkdG8KKwkJICogICAgICAgICAgICB0aGUgZHRvCisJCSAqIEBwYXJhbSBwcm9wZXJ0eQorCQkgKiAgICAgICAgICAgIHRoZSBwcm9wZXJ0eQorCQkgKiBAcGFyYW0gYWN0aW9uCisJCSAqICAgICAgICAgICAgdGhlIGFjdGlvbgorCQkgKiBAcmV0dXJuIHRoZSBwZXJtaXNzaW9uCisJCSAqLworCQlwdWJsaWMgc3RhdGljIFBlcm1pc3Npb24gZm9yRHRvUHJvcGVydHkoU3RyaW5nIGR0bywgU3RyaW5nIHByb3BlcnR5LCBBY3Rpb24gYWN0aW9uKSB7CisJCQlyZXR1cm4gbmV3IFBlcm1pc3Npb24oR3JvdXAuZHRvLCBkdG8sIHByb3BlcnR5LCBhY3Rpb24pOworCQl9CisKKwkJLyoqCisJCSAqIEluc3RhbnRpYXRlcyBhIG5ldyBwZXJtaXNzaW9uLgorCQkgKgorCQkgKiBAcGFyYW0gZ3JvdXAKKwkJICogICAgICAgICAgICB0aGUgZ3JvdXAKKwkJICogQHBhcmFtIGNsYXMKKwkJICogICAgICAgICAgICB0aGUgY2xhcworCQkgKiBAcGFyYW0gYWN0aW9uCisJCSAqICAgICAgICAgICAgdGhlIGFjdGlvbgorCQkgKi8KKwkJcHVibGljIFBlcm1pc3Npb24oR3JvdXAgZ3JvdXAsIFN0cmluZyBjbGFzLCBBY3Rpb24gYWN0aW9uKSB7CisJCQl0aGlzKFR5cGUuR1JBTlQsIGdyb3VwLCBjbGFzLCBudWxsLCBhY3Rpb24pOworCQl9CisKKwkJLyoqCisJCSAqIEluc3RhbnRpYXRlcyBhIG5ldyBwZXJtaXNzaW9uLgorCQkgKgorCQkgKiBAcGFyYW0gZ3JvdXAKKwkJICogICAgICAgICAgICB0aGUgZ3JvdXAKKwkJICogQHBhcmFtIGNsYXMKKwkJICogICAgICAgICAgICB0aGUgY2xhcworCQkgKiBAcGFyYW0gYXR0cmlidXRlCisJCSAqICAgICAgICAgICAgdGhlIGF0dHJpYnV0ZQorCQkgKiBAcGFyYW0gYWN0aW9uCisJCSAqICAgICAgICAgICAgdGhlIGFjdGlvbgorCQkgKi8KKwkJcHVibGljIFBlcm1pc3Npb24oR3JvdXAgZ3JvdXAsIFN0cmluZyBjbGFzLCBTdHJpbmcgYXR0cmlidXRlLCBBY3Rpb24gYWN0aW9uKSB7CisJCQl0aGlzKFR5cGUuR1JBTlQsIGdyb3VwLCBjbGFzLCBhdHRyaWJ1dGUsIGFjdGlvbik7CisJCX0KKworCQkvKioKKwkJICogSW5zdGFudGlhdGVzIGEgbmV3IHBlcm1pc3Npb24uCisJCSAqCisJCSAqIEBwYXJhbSB0eXBlCisJCSAqICAgICAgICAgICAgdGhlIHR5cGUKKwkJICogQHBhcmFtIGdyb3VwCisJCSAqICAgICAgICAgICAgdGhlIGdyb3VwCisJCSAqIEBwYXJhbSBjbGFzCisJCSAqICAgICAgICAgICAgdGhlIGNsYXMKKwkJICogQHBhcmFtIGF0dHJpYnV0ZQorCQkgKiAgICAgICAgICAgIHRoZSBhdHRyaWJ1dGUKKwkJICogQHBhcmFtIGFjdGlvbgorCQkgKiAgICAgICAgICAgIHRoZSBhY3Rpb24KKwkJICovCisJCXB1YmxpYyBQZXJtaXNzaW9uKFR5cGUgdHlwZSwgR3JvdXAgZ3JvdXAsIFN0cmluZyBjbGFzLCBTdHJpbmcgYXR0cmlidXRlLCBBY3Rpb24gYWN0aW9uKSB7CisJCQlmR3JvdXAgPSBncm91cDsKKwkJCWZDbGFzcyA9IGNsYXM7CisJCQlmQXR0cmlidXRlID0gYXR0cmlidXRlOworCQkJZkFjdGlvbiA9IGFjdGlvbjsKKwkJCWZUeXBlID0gdHlwZTsKKwkJfQorCisJCS8qCisJCSAqIChub24tSmF2YWRvYykKKwkJICogCisJCSAqIEBzZWUgamF2YS5sYW5nLk9iamVjdCN0b1N0cmluZygpCisJCSAqLworCQlwdWJsaWMgU3RyaW5nIHRvU3RyaW5nKCkgeworCQkJcmV0dXJuIGZHcm91cC50b1N0cmluZygpICsgU0VQQVJBVE9SICsgZkNsYXNzICsgU0VQQVJBVE9SICsgZkF0dHJpYnV0ZSArIFNFUEFSQVRPUiArIGZBY3Rpb24udG9TdHJpbmcoKTsKKwkJfQorCisJCS8qKgorCQkgKiBDaGVja3MgaWYgaXMgcGVybWl0dGVkLgorCQkgKgorCQkgKiBAcmV0dXJuIHRydWUsIGlmIGlzIHBlcm1pdHRlZAorCQkgKi8KKwkJcHVibGljIGJvb2xlYW4gaXNQZXJtaXR0ZWQoKSB7CisJCQlyZXR1cm4gZlR5cGUuaXNQZXJtaXR0ZWQoKTsKKwkJfQorCisJCS8qKgorCQkgKiBDaGVja3MgZm9yIHZldG8uCisJCSAqCisJCSAqIEByZXR1cm4gdHJ1ZSwgaWYgc3VjY2Vzc2Z1bAorCQkgKi8KKwkJcHVibGljIGJvb2xlYW4gaGFzVmV0bygpIHsKKwkJCXJldHVybiAhZlR5cGUuaXNQZXJtaXR0ZWQoKTsKKwkJfQorCisJCS8qKgorCQkgKiBDaGVja3MgaWYgcGVybWlzc2lvbiBpcyBmb3IgYW4gYXR0cmlidXRlLiBOZWdhdGl2ZSBsb2dpYyEKKwkJICoKKwkJICogQHJldHVybiB0cnVlLCBpZiBpcyBhdHRyaWJ1dGUKKwkJICovCisJCXB1YmxpYyBib29sZWFuIGlzQXR0cmlidXRlKCkgeworCQkJcmV0dXJuIGZBdHRyaWJ1dGUgIT0gbnVsbDsKKwkJfQorCX0KKworCS8qKgorCSAqIFRoZSBFbnVtIFR5cGUuCisJICovCisJcHVibGljIHN0YXRpYyBlbnVtIFR5cGUgeworCisJCS8qKiBUaGUgZ3JhbnQuICovCisJCUdSQU5UKHRydWUpLAorCQkvKiogVGhlIGRlbnkuICovCisJCURFTlkoZmFsc2UpOworCisJCS8qKiBUaGUgcGVybWl0dGVkLiAqLworCQlwcml2YXRlIGZpbmFsIGJvb2xlYW4gZlBlcm1pdHRlZDsKKworCQkvKioKKwkJICogSW5zdGFudGlhdGVzIGEgbmV3IHR5cGUuCisJCSAqCisJCSAqIEBwYXJhbSBwZXJtaXR0ZWQKKwkJICogICAgICAgICAgICB0aGUgcGVybWl0dGVkCisJCSAqLworCQlwcml2YXRlIFR5cGUoYm9vbGVhbiBwZXJtaXR0ZWQpIHsKKwkJCWZQZXJtaXR0ZWQgPSBwZXJtaXR0ZWQ7CisJCX0KKworCQkvKioKKwkJICogQ2hlY2tzIGlmIGlzIHBlcm1pdHRlZC4KKwkJICoKKwkJICogQHJldHVybiB0cnVlLCBpZiBpcyBwZXJtaXR0ZWQKKwkJICovCisJCXB1YmxpYyBib29sZWFuIGlzUGVybWl0dGVkKCkgeworCQkJcmV0dXJuIGZQZXJtaXR0ZWQ7CisJCX0KKwl9CisKKwkvKioKKwkgKiBUaGUgRW51bSBHcm91cC4KKwkgKi8KKwlwdWJsaWMgc3RhdGljIGVudW0gR3JvdXAgeworCisJCS8qKiBUaGUgYmxpcCBwcm9jZXNzIHN0YXJ0LiAqLworCQlibGlwUHJvY2VzcyhBY3Rpb24uc3RhcnRhYmxlKSwKKworCQkvKiogVGhlIGJsaXAgdXNlciB0YXNrIGV4ZWN1dGUuICovCisJCWJsaXBVc2VyVGFzayhBY3Rpb24uZXhlY3V0YWJsZSksCisKKwkJLyoqIFRoZSBlbnRpdHkuICovCisJCWVudGl0eShBY3Rpb24ucmVhZGFibGUsIEFjdGlvbi5jcmVhdGFibGUsIEFjdGlvbi51cGRhdGFibGUsIEFjdGlvbi5kZWxldGFibGUpLAorCisJCS8qKiBUaGUgYmVhbi4gKi8KKwkJYmVhbihBY3Rpb24ucmVhZGFibGUsIEFjdGlvbi5jcmVhdGFibGUsIEFjdGlvbi51cGRhdGFibGUsIEFjdGlvbi5kZWxldGFibGUpLAorCisJCS8qKiBUaGUgZHRvLiAqLworCQlkdG8oQWN0aW9uLnJlYWRhYmxlLCBBY3Rpb24uY3JlYXRhYmxlLCBBY3Rpb24udXBkYXRhYmxlLCBBY3Rpb24uZGVsZXRhYmxlKTsKKworCQkvKiogVGhlIGRlZmF1bHQgYWN0aW9uLiAqLworCQlwcml2YXRlIGZpbmFsIEFjdGlvbiBmRGVmYXVsdEFjdGlvbjsKKworCQkvKiogVGhlIGFueSBhY3Rpb25zLiAqLworCQlwcml2YXRlIGZpbmFsIEFjdGlvbltdIGZBbnlBY3Rpb25zOworCisJCS8qKgorCQkgKiBJbnN0YW50aWF0ZXMgYSBuZXcgZ3JvdXAuCisJCSAqCisJCSAqIEBwYXJhbSBkZWZhdWx0QWN0aW9uCisJCSAqICAgICAgICAgICAgdGhlIGRlZmF1bHQgYWN0aW9uCisJCSAqIEBwYXJhbSBhbnlBY3Rpb25zCisJCSAqICAgICAgICAgICAgdGhlIGFueSBhY3Rpb25zCisJCSAqLworCQlwcml2YXRlIEdyb3VwKEFjdGlvbiBkZWZhdWx0QWN0aW9uLCBBY3Rpb24uLi4gYW55QWN0aW9ucykgeworCQkJZkRlZmF1bHRBY3Rpb24gPSBkZWZhdWx0QWN0aW9uOworCQkJZkFueUFjdGlvbnMgPSBhbnlBY3Rpb25zOworCQl9CisKKwkJLyoqCisJCSAqIEJ5IG5hbWUuCisJCSAqCisJCSAqIEBwYXJhbSB2YWx1ZQorCQkgKiAgICAgICAgICAgIHRoZSB2YWx1ZQorCQkgKiBAcmV0dXJuIHRoZSBncm91cAorCQkgKi8KKwkJcHVibGljIHN0YXRpYyBHcm91cCBieU5hbWUoU3RyaW5nIHZhbHVlKSB7CisJCQlmb3IgKEdyb3VwIGl0ZW0gOiB2YWx1ZXMoKSkgeworCQkJCWlmICh2YWx1ZS5lcXVhbHNJZ25vcmVDYXNlKGl0ZW0udG9TdHJpbmcoKSkpIHsKKwkJCQkJcmV0dXJuIGl0ZW07CisJCQkJfQorCQkJfQorCQkJcmV0dXJuIG51bGw7CisJCX0KKworCQkvKioKKwkJICogQ2hlY2tzIGZvciBkZWZhdWx0IGFjdGlvbi4KKwkJICoKKwkJICogQHJldHVybiB0cnVlLCBpZiBzdWNjZXNzZnVsCisJCSAqLworCQlwdWJsaWMgYm9vbGVhbiBoYXNEZWZhdWx0QWN0aW9uKCkgeworCQkJcmV0dXJuIChmRGVmYXVsdEFjdGlvbiAhPSBudWxsKTsKKwkJfQorCisJCS8qKgorCQkgKiBHZXRzIHRoZSBkZWZhdWx0IGFjdGlvbi4KKwkJICoKKwkJICogQHJldHVybiB0aGUgZGVmYXVsdCBhY3Rpb24KKwkJICovCisJCXB1YmxpYyBBY3Rpb24gZ2V0RGVmYXVsdEFjdGlvbigpIHsKKwkJCXJldHVybiBmRGVmYXVsdEFjdGlvbjsKKwkJfQorCisJCS8qKgorCQkgKiBHZXRzIHRoZSBhbnkgYWN0aW9ucy4KKwkJICoKKwkJICogQHJldHVybiB0aGUgYW55IGFjdGlvbnMKKwkJICovCisJCXB1YmxpYyBBY3Rpb25bXSBnZXRBbnlBY3Rpb25zKCkgeworCQkJcmV0dXJuIGZBbnlBY3Rpb25zOworCQl9CisJfQorCisJLyoqCisJICogVGhlIEVudW0gQWN0aW9uLgorCSAqLworCXB1YmxpYyBzdGF0aWMgZW51bSBBY3Rpb24geworCisJCS8qKiBjYW4gYSBuZXcgZW50aXR5IGluc3RhbmNlIGJlIENSRUFURUQuICovCisJCWNyZWF0YWJsZSwKKworCQkvKiogY2FuIGFuIGVudGl0eSBpbnN0YW5jZSBiZSBSRUFELiAqLworCQlyZWFkYWJsZSwKKworCQkvKiogY2FuIGFuIGVudGl0eSBpbnN0YW5jZSBiZSBVUERBVEVELiAqLworCQl1cGRhdGFibGUsCisKKwkJLyoqIGNhbiBhbiBlbnRpdHkgaW5zdGFuY2UgYmUgREVMRVRFRC4gKi8KKwkJZGVsZXRhYmxlLAorCisJCS8qKiBjYW4gYW4gZW50aXR5IGluc3RhbmNlIGJlIENSRUFURUQsIFJFQUQsIFVQREFURUQgYW5kIERFTEVURUQuICovCisJCWFueSwKKwkJLyoqIGlzIHRoZSBlbnRpdHkucHJvcGVydHkgSU5WSVNJQkxFLCBvdGhlcndpc2UgYXQgbGVhc3QgdmlzaWJsZSAqLworCQlpbnZpc2libGUsCisJCS8qKiBpcyBlbnRpdHkucHJvcGVydHkgRElTQUJMRUQsIG90aGVyd2lzZSBhdCBsZWFzdCBlbmFibGVkICovCisJCWRpc2FibGVkKGludmlzaWJsZSksCisJCS8qKiBpcyBlbnRpdHkucHJvcGVydHkgTk9ORURJVEFCTEUsIG90aGVyd2lzZSBhdCBsZWFzdCBlZGl0YWJsZSAqLworCQlub25lZGl0YWJsZShkaXNhYmxlZCksCisKKwkJLyoqIGlzIHRoZSBibGlwIHByb2Nlc3Mgc3RhcnRhYmxlLiAqLworCQlzdGFydGFibGUsCisKKwkJLyoqIGlzIHRoZSBibGlwIHVzZXIgdGFzayBldmVudCBleGVjdXRhYmxlLiAqLworCQlleGVjdXRhYmxlOworCQkKKwkJLyoqIFRoZSBkZXBlbmRzIG9uIGFjdGlvbi4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBBY3Rpb24gZkRlcGVuZHNPbkFjdGlvbjsKKworCQkvKiogVGhlIGF1dG8gZ3JhbnRlZCBhY3Rpb25zLiAqLworCQlwcml2YXRlIFNldDxBY3Rpb24+IGZBdXRvR3JhbnRlZEFjdGlvbnM7CisKKwkJLyoqIFRoZSBhdXRvIGRlbmllZCBhY3Rpb25zLiAqLworCQlwcml2YXRlIFNldDxBY3Rpb24+IGZBdXRvRGVuaWVkQWN0aW9uczsKKworCQkvKioKKwkJICogSW5zdGFudGlhdGVzIGEgbmV3IGFjdGlvbi4KKwkJICovCisJCXByaXZhdGUgQWN0aW9uKCkgeworCQkJdGhpcyhudWxsKTsKKwkJfQorCisJCS8qKgorCQkgKiBJbnN0YW50aWF0ZXMgYSBuZXcgYWN0aW9uLgorCQkgKgorCQkgKiBAcGFyYW0gZGVwZW5kc09uQWN0aW9uCisJCSAqICAgICAgICAgICAgdGhlIGRlcGVuZHMgb24gYWN0aW9uCisJCSAqLworCQlwcml2YXRlIEFjdGlvbihBY3Rpb24gZGVwZW5kc09uQWN0aW9uKSB7CisJCQlmRGVwZW5kc09uQWN0aW9uID0gZGVwZW5kc09uQWN0aW9uOworCQl9CisKKwkJLyoqCisJCSAqIEJ5IG5hbWUuCisJCSAqCisJCSAqIEBwYXJhbSB2YWx1ZQorCQkgKiAgICAgICAgICAgIHRoZSB2YWx1ZQorCQkgKiBAcmV0dXJuIHRoZSBhY3Rpb24KKwkJICovCisJCXB1YmxpYyBzdGF0aWMgQWN0aW9uIGJ5TmFtZShTdHJpbmcgdmFsdWUpIHsKKwkJCWlmICh2YWx1ZSAhPSBudWxsKSB7CisJCQkJZm9yIChBY3Rpb24gaXRlbSA6IHZhbHVlcygpKSB7CisJCQkJCWlmICh2YWx1ZS5lcXVhbHNJZ25vcmVDYXNlKGl0ZW0udG9TdHJpbmcoKSkpIHsKKwkJCQkJCXJldHVybiBpdGVtOworCQkJCQl9CisJCQkJfQorCQkJfQorCQkJcmV0dXJuIG51bGw7CisJCX0KKworCQkvKioKKwkJICogQ2hlY2sgYXV0byBncmFudGVkIGFjdGlvbnMuCisJCSAqLworCQlwcml2YXRlIHZvaWQgY2hlY2tBdXRvR3JhbnRlZEFjdGlvbnMoKSB7CisJCQlpZiAoZkF1dG9HcmFudGVkQWN0aW9ucyA9PSBudWxsKSB7CisJCQkJZkF1dG9HcmFudGVkQWN0aW9ucyA9IG5ldyBIYXNoU2V0PEFjdGlvbj4oKTsKKwkJCQlpZiAoZkRlcGVuZHNPbkFjdGlvbiAhPSBudWxsKSB7CisJCQkJCWZBdXRvR3JhbnRlZEFjdGlvbnMuYWRkKGZEZXBlbmRzT25BY3Rpb24pOworCQkJCQlmQXV0b0dyYW50ZWRBY3Rpb25zLmFkZEFsbChmRGVwZW5kc09uQWN0aW9uLmdldEF1dG9HcmFudGVkQWN0aW9ucygpKTsKKwkJCQl9CisJCQl9CisJCX0KKworCQkvKioKKwkJICogQ2hlY2sgYXV0byBkZW5pZWQgYWN0aW9ucy4KKwkJICovCisJCXByaXZhdGUgdm9pZCBjaGVja0F1dG9EZW5pZWRBY3Rpb25zKCkgeworCQkJaWYgKGZBdXRvRGVuaWVkQWN0aW9ucyA9PSBudWxsKSB7CisJCQkJZkF1dG9EZW5pZWRBY3Rpb25zID0gbmV3IEhhc2hTZXQ8QWN0aW9uPigpOworCQkJCWZvciAoQWN0aW9uIGNoZWNrQWN0aW9uIDogdmFsdWVzKCkpIHsKKwkJCQkJaWYgKHRoaXMuZXF1YWxzKGNoZWNrQWN0aW9uLmZEZXBlbmRzT25BY3Rpb24pKSB7CisJCQkJCQlmQXV0b0RlbmllZEFjdGlvbnMuYWRkKGNoZWNrQWN0aW9uKTsKKwkJCQkJCWZBdXRvRGVuaWVkQWN0aW9ucy5hZGRBbGwoY2hlY2tBY3Rpb24uZ2V0QXV0b0RlbmllZEFjdGlvbnMoKSk7CisJCQkJCX0KKwkJCQl9CisJCQl9CisJCX0KKworCQkvKioKKwkJICogQ2hlY2tzIGZvciBhdXRvIGdyYW50ZWQgYWN0aW9ucy4KKwkJICoKKwkJICogQHJldHVybiB0cnVlLCBpZiBzdWNjZXNzZnVsCisJCSAqLworCQlwdWJsaWMgYm9vbGVhbiBoYXNBdXRvR3JhbnRlZEFjdGlvbnMoKSB7CisJCQljaGVja0F1dG9HcmFudGVkQWN0aW9ucygpOworCQkJcmV0dXJuICFmQXV0b0dyYW50ZWRBY3Rpb25zLmlzRW1wdHkoKTsKKwkJfQorCisJCS8qKgorCQkgKiBHZXRzIHRoZSBhdXRvIGdyYW50ZWQgYWN0aW9ucy4KKwkJICoKKwkJICogQHJldHVybiB0aGUgYXV0byBncmFudGVkIGFjdGlvbnMKKwkJICovCisJCXB1YmxpYyBTZXQ8QWN0aW9uPiBnZXRBdXRvR3JhbnRlZEFjdGlvbnMoKSB7CisJCQljaGVja0F1dG9HcmFudGVkQWN0aW9ucygpOworCQkJcmV0dXJuIGZBdXRvR3JhbnRlZEFjdGlvbnM7CisJCX0KKworCQkvKioKKwkJICogQ2hlY2tzIGZvciBhdXRvIGRlbmllZCBhY3Rpb25zLgorCQkgKgorCQkgKiBAcmV0dXJuIHRydWUsIGlmIHN1Y2Nlc3NmdWwKKwkJICovCisJCXB1YmxpYyBib29sZWFuIGhhc0F1dG9EZW5pZWRBY3Rpb25zKCkgeworCQkJY2hlY2tBdXRvRGVuaWVkQWN0aW9ucygpOworCQkJcmV0dXJuICFmQXV0b0RlbmllZEFjdGlvbnMuaXNFbXB0eSgpOworCQl9CisKKwkJLyoqCisJCSAqIEdldHMgdGhlIGF1dG8gZGVuaWVkIGFjdGlvbnMuCisJCSAqCisJCSAqIEByZXR1cm4gdGhlIGF1dG8gZGVuaWVkIGFjdGlvbnMKKwkJICovCisJCXB1YmxpYyBTZXQ8QWN0aW9uPiBnZXRBdXRvRGVuaWVkQWN0aW9ucygpIHsKKwkJCWNoZWNrQXV0b0RlbmllZEFjdGlvbnMoKTsKKwkJCXJldHVybiBmQXV0b0RlbmllZEFjdGlvbnM7CisJCX0KKwl9CisKKwkvKioKKwkgKiBUaGUgRW51bSBQZXJtaXNzaW9uUmVzdWx0LgorCSAqLworCXB1YmxpYyBzdGF0aWMgZW51bSBQZXJtaXNzaW9uUmVzdWx0IHsKKworCQkvKiogVGhlIGV4cGxpY2l0IGdyYW50ZWQuICovCisJCUVYUExJQ0lUX0dSQU5URUQodHJ1ZSwgdHJ1ZSksCisKKwkJLyoqIFRoZSBleHBsaWNpdCBkZW5pZWQuICovCisJCUVYUExJQ0lUX0RFTklFRCh0cnVlLCBmYWxzZSksCisKKwkJLyoqIFRoZSBpbXBsaWNpdCBkZW5pZWQuICovCisJCUlNUExJQ0lUX0RFTklFRChmYWxzZSwgZmFsc2UpOworCisJCS8qKiBUaGUgcGVybWl0dGVkLiAqLworCQlwcml2YXRlIGZpbmFsIGJvb2xlYW4gZlBlcm1pdHRlZDsKKworCQkvKiogVGhlIGV4cGxpY2l0LiAqLworCQlwcml2YXRlIGZpbmFsIGJvb2xlYW4gZkV4cGxpY2l0OworCisJCS8qKgorCQkgKiBJbnN0YW50aWF0ZXMgYSBuZXcgcGVybWlzc2lvbiByZXN1bHQuCisJCSAqCisJCSAqIEBwYXJhbSBleHBsaWNpdAorCQkgKiAgICAgICAgICAgIHRoZSBleHBsaWNpdAorCQkgKiBAcGFyYW0gcGVybWl0dGVkCisJCSAqICAgICAgICAgICAgdGhlIHBlcm1pdHRlZAorCQkgKi8KKwkJcHJpdmF0ZSBQZXJtaXNzaW9uUmVzdWx0KGJvb2xlYW4gZXhwbGljaXQsIGJvb2xlYW4gcGVybWl0dGVkKSB7CisJCQlmRXhwbGljaXQgPSBleHBsaWNpdDsKKwkJCWZQZXJtaXR0ZWQgPSBwZXJtaXR0ZWQ7CisJCX0KKworCQkvKioKKwkJICogQ2hlY2tzIGlmIGlzIGV4cGxpY2l0LgorCQkgKgorCQkgKiBAcmV0dXJuIHRydWUsIGlmIGlzIGV4cGxpY2l0CisJCSAqLworCQlwdWJsaWMgYm9vbGVhbiBpc0V4cGxpY2l0KCkgeworCQkJcmV0dXJuIGZFeHBsaWNpdDsKKwkJfQorCisJCS8qKgorCQkgKiBDaGVja3MgaWYgaXMgcGVybWl0dGVkLgorCQkgKgorCQkgKiBAcmV0dXJuIHRydWUsIGlmIGlzIHBlcm1pdHRlZAorCQkgKi8KKwkJcHVibGljIGJvb2xlYW4gaXNQZXJtaXR0ZWQoKSB7CisJCQlyZXR1cm4gZlBlcm1pdHRlZDsKKwkJfQorCX0KK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0Fic3RyYWN0T3JnRWxlbWVudC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvQWJzdHJhY3RPcmdFbGVtZW50LmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmJhN2Q2NgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0Fic3RyYWN0T3JnRWxlbWVudC5qYXZhCkBAIC0wLDAgKzEsMTMwIEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3M7CisKKworLy8gVE9ETzogQXV0by1nZW5lcmF0ZWQgSmF2YWRvYworLyoqCisgKiBUaGUgQ2xhc3MgQVBvc2l0aW9uLgorICovCitwdWJsaWMgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RPcmdFbGVtZW50IGltcGxlbWVudHMgSU9yZ0VsZW1lbnQgeworCisJLyoqIFRoZSBDb25zdGFudCBzZXJpYWxWZXJzaW9uVUlELiAqLworCXByaXZhdGUgc3RhdGljIGZpbmFsIGxvbmcgc2VyaWFsVmVyc2lvblVJRCA9IDg2NTQzNTMxOTIxNjc0NzczNDlMOworCisJLyoqIFRoZSByb290IG5vZGUuICovCisJcHJpdmF0ZSBJT3JnRWxlbWVudCByb290Tm9kZTsKKworCS8qKiBUaGUgb3JnYW5pemF0aW9uIHRoZSBub2RlIGJlbG9uZ3MgdG8uICovCisJcHJpdmF0ZSBJU3ViT3JnYW5pemF0aW9uIG9yZ2FuaXphdGlvbjsKKworCS8qKiBUaGUgc3VwZXIgb3JkaW5hdGUuICovCisJcHJpdmF0ZSBJT3JnRWxlbWVudCBzdXBlck9yZGluYXRlID0gbnVsbDsKKworCS8qKiBUaGUgbmFtZSBvZiB0aGUgbm9kZS4gKi8KKwlwcml2YXRlIFN0cmluZyBuYW1lOworCisJcHVibGljIElPcmdFbGVtZW50IGdldFN1cGVyT3JkaW5hdGUoKSB7CisJCXJldHVybiBzdXBlck9yZGluYXRlOworCX0KKworCXB1YmxpYyB2b2lkIHNldFN1cGVyT3JkaW5hdGUoSU9yZ0VsZW1lbnQgc3VwZXJPcmRpbmF0ZSkgeworCQl0aGlzLnN1cGVyT3JkaW5hdGUgPSBzdXBlck9yZGluYXRlOworCX0KKworCXB1YmxpYyB2b2lkIHNldFJvb3ROb2RlKElPcmdFbGVtZW50IHJvb3ROb2RlKSB7CisJCXRoaXMucm9vdE5vZGUgPSByb290Tm9kZTsKKwl9CisKKwkvKgorCSAqIChub24tSmF2YWRvYykKKwkgKiAKKwkgKiBAc2VlIG9yZy5lY2xpcHNlLm9zYnAuYXV0aGVudGljYXRpb24ucHJvdmlkZXIuSU9yZ05vZGUjZ2V0TmFtZSgpCisJICovCisJQE92ZXJyaWRlCisJcHVibGljIFN0cmluZyBnZXROYW1lKCkgeworCQlyZXR1cm4gbmFtZTsKKwl9CisKKwlwdWJsaWMgdm9pZCBzZXROYW1lKFN0cmluZyBuYW1lKSB7CisJCXRoaXMubmFtZSA9IG5hbWU7CisJfQorCisJLyoKKwkgKiAobm9uLUphdmFkb2MpCisJICogCisJICogQHNlZSBvcmcuZWNsaXBzZS5vc2JwLmF1dGhlbnRpY2F0aW9uLnByb3ZpZGVyLklPcmdOb2RlI2hhc1N1cGVyaW9yKCkKKwkgKi8KKwlAT3ZlcnJpZGUKKwlwdWJsaWMgYm9vbGVhbiBoYXNTdXBlcmlvcigpIHsKKwkJcmV0dXJuIHN1cGVyT3JkaW5hdGUgIT0gbnVsbDsKKwl9CisKKwkvKioKKwkgKiBHZXRzIHRoZSBzdXBlcmlvciBvcmcgbm9kZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHN1cGVyaW9yIG9yZyBub2RlCisJICovCisJcHVibGljIElPcmdFbGVtZW50IGdldFN1cGVyaW9yT3JnTm9kZSgpIHsKKwkJcmV0dXJuIHN1cGVyT3JkaW5hdGU7CisJfQorCisJLyoKKwkgKiAobm9uLUphdmFkb2MpCisJICogCisJICogQHNlZSBvcmcuZWNsaXBzZS5vc2JwLmF1dGhlbnRpY2F0aW9uLnByb3ZpZGVyLklPcmdOb2RlI2dldFN1cGVyaW9yKCkKKwkgKi8KKwlAT3ZlcnJpZGUKKwlwdWJsaWMgU3RyaW5nIGdldFN1cGVyaW9yKCkgeworCQlyZXR1cm4gc3VwZXJPcmRpbmF0ZSA9PSBudWxsID8gbnVsbCA6IHN1cGVyT3JkaW5hdGUuZ2V0TmFtZSgpOworCX0KKworCS8qCisJICogKG5vbi1KYXZhZG9jKQorCSAqIAorCSAqIEBzZWUgb3JnLmVjbGlwc2Uub3NicC5hdXRoZW50aWNhdGlvbi5wcm92aWRlci5JT3JnTm9kZSNoYXNSb290Tm9kZSgpCisJICovCisJQE92ZXJyaWRlCisJcHVibGljIGJvb2xlYW4gaGFzUm9vdE5vZGUoKSB7CisJCXJldHVybiBzdXBlck9yZGluYXRlICE9IG51bGw7CisJfQorCisJLyoqCisJICogR2V0cyB0aGUgcm9vdCBub2RlIG9yZyBub2RlLgorCSAqCisJICogQHJldHVybiB0aGUgcm9vdCBub2RlIG9yZyBub2RlCisJICovCisJcHVibGljIElPcmdFbGVtZW50IGdldFJvb3ROb2RlT3JnTm9kZSgpIHsKKwkJcmV0dXJuIHJvb3ROb2RlOworCX0KKworCS8qCisJICogKG5vbi1KYXZhZG9jKQorCSAqIAorCSAqIEBzZWUgb3JnLmVjbGlwc2Uub3NicC5hdXRoZW50aWNhdGlvbi5wcm92aWRlci5JT3JnTm9kZSNnZXRSb290Tm9kZSgpCisJICovCisJQE92ZXJyaWRlCisJcHVibGljIFN0cmluZyBnZXRSb290Tm9kZSgpIHsKKwkJcmV0dXJuIHJvb3ROb2RlID09IG51bGwgPyBudWxsIDogcm9vdE5vZGUuZ2V0TmFtZSgpOworCX0KKworCUBPdmVycmlkZQorCXB1YmxpYyBJU3ViT3JnYW5pemF0aW9uIGdldE9yZ2FuaXphdGlvbigpIHsKKwkJcmV0dXJuIG9yZ2FuaXphdGlvbjsKKwl9CisKKwlwdWJsaWMgdm9pZCBzZXRPcmdhbml6YXRpb24oSVN1Yk9yZ2FuaXphdGlvbiBvcmdhbml6YXRpb24pIHsKKwkJdGhpcy5vcmdhbml6YXRpb24gPSBvcmdhbml6YXRpb247CisJfQorCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvdXNlcmFjY2Vzcy9BYnN0cmFjdFBvc2l0aW9uLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvdXNlcmFjY2Vzcy9BYnN0cmFjdFBvc2l0aW9uLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjk3NDkzNwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0Fic3RyYWN0UG9zaXRpb24uamF2YQpAQCAtMCwwICsxLDY1IEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3M7CisKK2ltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaFNldDsKK2ltcG9ydCBqYXZhLnV0aWwuU2V0OworCisvLyBUT0RPOiBBdXRvLWdlbmVyYXRlZCBKYXZhZG9jCisvKioKKyAqIFRoZSBDbGFzcyBBUG9zaXRpb24uCisgKi8KK3B1YmxpYyBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdFBvc2l0aW9uIGV4dGVuZHMgQWJzdHJhY3RPcmdFbGVtZW50IGltcGxlbWVudHMgSVBvc2l0aW9uIHsKKworCS8qKiBUaGUgQ29uc3RhbnQgc2VyaWFsVmVyc2lvblVJRC4gKi8KKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBsb25nIHNlcmlhbFZlcnNpb25VSUQgPSA4NjU0MzUzMTkyMTY3NDc3MzQ5TDsKKworCS8qKiBUaGUgcm9sZSBuYW1lcy4gKi8KKwlwcml2YXRlIFNldDxTdHJpbmc+IHJvbGVOYW1lcyA9IG5ldyBIYXNoU2V0PD4oKTsKKworCS8qKiBUaGUgcGVybWlzc2lvbiBsaXN0LiAqLworCXByaXZhdGUgSVBlcm1pc3Npb25MaXN0IHBlcm1pc3Npb25zOworCisJcHVibGljIHZvaWQgc2V0Um9sZXMoU2V0PFN0cmluZz4gcm9sZXMpIHsKKwkJdGhpcy5yb2xlTmFtZXMgPSByb2xlczsKKwl9CisKKwkvKioKKwkgKiBBZGRzIGEgcm9sZQorCSAqCisJICogQHBhcmFtIHJvbGUKKwkgKiAgICAgICAgICAgIHRoZSByb2xlCisJICovCisJcHVibGljIHZvaWQgYWRkUm9sZShTdHJpbmcgcm9sZSkgeworCQlyb2xlTmFtZXMuYWRkKHJvbGUpOworCX0KKworCS8qKgorCSAqIEdldHMgdGhlIHJvbGVzLgorCSAqCisJICogQHJldHVybiB0aGUgcm9sZXMKKwkgKi8KKwlwdWJsaWMgQ29sbGVjdGlvbjxTdHJpbmc+IGdldFJvbGVzKCkgeworCQlyZXR1cm4gcm9sZU5hbWVzOworCX0KKworCUBPdmVycmlkZQorCXB1YmxpYyBJUGVybWlzc2lvbkxpc3QgZ2V0UGVybWlzc2lvbkxpc3QoKSB7CisJCXJldHVybiBwZXJtaXNzaW9uczsKKwl9CisKKwlwdWJsaWMgdm9pZCBzZXRQZXJtaXNzaW9uTGlzdChJUGVybWlzc2lvbkxpc3QgcGVybWlzc2lvbnMpIHsKKwkJdGhpcy5wZXJtaXNzaW9ucyA9IHBlcm1pc3Npb25zOworCX0KK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0Fic3RyYWN0Um9sZUF1dGhvcml6YXRpb25Hcm91cC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvQWJzdHJhY3RSb2xlQXV0aG9yaXphdGlvbkdyb3VwLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmRiNWUyYgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0Fic3RyYWN0Um9sZUF1dGhvcml6YXRpb25Hcm91cC5qYXZhCkBAIC0wLDAgKzEsMTg1IEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3M7CisKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaFNldDsKK2ltcG9ydCBqYXZhLnV0aWwuTWFwOworaW1wb3J0IGphdmEudXRpbC5TZXQ7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS51c2VyYWNjZXNzLkFic3RyYWN0QXV0aG9yaXphdGlvbi5BY3Rpb247CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudXNlcmFjY2Vzcy5BYnN0cmFjdEF1dGhvcml6YXRpb24uR3JvdXA7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudXNlcmFjY2Vzcy5BYnN0cmFjdEF1dGhvcml6YXRpb24uUGVybWlzc2lvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS51c2VyYWNjZXNzLkFic3RyYWN0QXV0aG9yaXphdGlvbi5UeXBlOworCisvLyBUT0RPOiBBdXRvLWdlbmVyYXRlZCBKYXZhZG9jCisvKioKKyAqIFRoZSBDbGFzcyBBUm9sZUF1dGhvcml6YXRpb25Hcm91cC4KKyAqLworcHVibGljIGFic3RyYWN0IGNsYXNzIEFic3RyYWN0Um9sZUF1dGhvcml6YXRpb25Hcm91cCB7CisKKwkvKiogVGhlIHBlcm1pc3Npb25zLiAqLworCXByaXZhdGUgTWFwPFN0cmluZyxCb29sZWFuPiBmUGVybWlzc2lvbnMgPSBuZXcgSGFzaE1hcDw+KCk7IAorCisJLyoqCisJICogSW5zdGFudGlhdGVzIGEgbmV3IGEgcm9sZSBhdXRob3JpemF0aW9uIGdyb3VwLgorCSAqCisJICogQHBhcmFtIHBlcm1pc3Npb25TZXRzIHRoZSBwZXJtaXNzaW9uIHNldHMKKwkgKi8KKwlAU2FmZVZhcmFyZ3MKKwlwcm90ZWN0ZWQgQWJzdHJhY3RSb2xlQXV0aG9yaXphdGlvbkdyb3VwKFNldDxQZXJtaXNzaW9uPi4uLiBwZXJtaXNzaW9uU2V0cykgeworCQlmb3IgKFNldDxQZXJtaXNzaW9uPiBwZXJtaXNzaW9uU2V0IDogcGVybWlzc2lvblNldHMpIHsKKwkJCWZvciAoUGVybWlzc2lvbiBwZXJtaXNzaW9uIDogcGVybWlzc2lvblNldCkgeworCQkJCWZQZXJtaXNzaW9ucy5wdXQocGVybWlzc2lvbi50b1N0cmluZygpLCBwZXJtaXNzaW9uLmlzUGVybWl0dGVkKCkpOworCQkJfQorCQl9CisJfQorCQorCS8qKgorCSAqIEFkZHMgdGhlIHBlcm1pc3Npb24uCisJICoKKwkgKiBAcGFyYW0gcGVybWlzc2lvbiB0aGUgcGVybWlzc2lvbgorCSAqLworCXB1YmxpYyBmaW5hbCB2b2lkIGFkZFBlcm1pc3Npb24oUGVybWlzc2lvbiBwZXJtaXNzaW9uKSB7CisJCWZQZXJtaXNzaW9ucy5wdXQocGVybWlzc2lvbi50b1N0cmluZygpLCBwZXJtaXNzaW9uLmlzUGVybWl0dGVkKCkpOworCX0KKworCS8qKgorCSAqIEdldHMgdGhlIG5hbWUuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBuYW1lCisJICovCisJcHVibGljIGZpbmFsIFN0cmluZyBnZXROYW1lKCkgeworCQlyZXR1cm4gZ2V0Um9sZU5hbWUoKTsKKwl9CisJCisJLyoqCisJICogR2V0cyB0aGUgcm9sZSBuYW1lLgorCSAqCisJICogQHJldHVybiB0aGUgcm9sZSBuYW1lCisJICovCisJcHVibGljIGZpbmFsIFN0cmluZyBnZXRSb2xlTmFtZSgpIHsKKwkJcmV0dXJuIHRoaXMuZ2V0Q2xhc3MoKS5nZXRTaW1wbGVOYW1lKCk7CisJfQorCQorLy8JZmluYWwgcHVibGljIE1hcDxTdHJpbmcsQm9vbGVhbj4gZ2V0UGVybWlzc2lvbnMoKSB7IC8vIE5PU09OQVIKKy8vCQlyZXR1cm4gZlBlcm1pc3Npb25zOyAvLyBOT1NPTkFSCisvLwl9IC8vIE5PU09OQVIKKwkKKwkvKioKKyAqIEdldHMgdGhlIHBlcm1pc3Npb24ga2V5cy4KKyAqCisgKiBAcmV0dXJuIHRoZSBwZXJtaXNzaW9uIGtleXMKKyAqLworcHVibGljIGZpbmFsIFNldDxTdHJpbmc+IGdldFBlcm1pc3Npb25LZXlzKCkgeworCQlyZXR1cm4gZlBlcm1pc3Npb25zLmtleVNldCgpOworCX0KKwkKKwkvKioKKwkgKiBFeGlzdHMgcGVybWlzc2lvbiBrZXlzLgorCSAqCisJICogQHBhcmFtIGtleSB0aGUga2V5CisJICogQHJldHVybiB0cnVlLCBpZiBzdWNjZXNzZnVsCisJICovCisJcHVibGljIGZpbmFsIGJvb2xlYW4gZXhpc3RzUGVybWlzc2lvbktleXMoU3RyaW5nIGtleSkgeworCQlyZXR1cm4gZlBlcm1pc3Npb25zLmNvbnRhaW5zS2V5KGtleSk7CisJfQorCQorCS8qKgorCSAqIEdldHMgdGhlIHBlcm1pc3Npb24uCisJICoKKwkgKiBAcGFyYW0ga2V5IHRoZSBrZXkKKwkgKiBAcmV0dXJuIHRoZSBwZXJtaXNzaW9uCisJICovCisJcHVibGljIGZpbmFsIGJvb2xlYW4gZ2V0UGVybWlzc2lvbihTdHJpbmcga2V5KSB7CisJCXJldHVybiBmUGVybWlzc2lvbnMuZ2V0KGtleSk7CisJfQorCisJLyoqCisJICogR3JhbnRlZC4KKwkgKgorCSAqIEBwYXJhbSBncm91cCB0aGUgZ3JvdXAKKwkgKiBAcGFyYW0gY2xhcyB0aGUgY2xhcworCSAqIEBwYXJhbSBhY3Rpb25zIHRoZSBhY3Rpb25zCisJICogQHJldHVybiB0aGUgc2V0cyB0aGUKKwkgKi8KKwlwdWJsaWMgc3RhdGljIGZpbmFsIFNldDxQZXJtaXNzaW9uPiBncmFudGVkKEdyb3VwIGdyb3VwLCBTdHJpbmcgY2xhcywgQWN0aW9uLi4uIGFjdGlvbnMpIHsKKwkJU2V0PFBlcm1pc3Npb24+IGdyYW50ZWQgPSBuZXcgSGFzaFNldDw+KCk7CisJCS8vIC0tLSBhbnkgZGVmYXVsdCBhdXRob3JpemF0aW9ucyAtLS0KKwkJaWYgIChncm91cC5oYXNEZWZhdWx0QWN0aW9uKCkpIHsKKwkJCWdyYW50ZWQuYWRkKG5ldyBQZXJtaXNzaW9uKGdyb3VwLCBjbGFzLCBncm91cC5nZXREZWZhdWx0QWN0aW9uKCkpKTsKKwkJfQorCQkvLyAtLS0gaWYgdGhlIEFOWS1hdXRob3JpemF0aW9uIGlzIGdpdmVuIC0tLQorCQlpZiAgKChhY3Rpb25zLmxlbmd0aCA9PSAxKSAmJiBhY3Rpb25zWzBdLmVxdWFscyhBY3Rpb24uYW55KSkgeworCQkJZm9yIChBY3Rpb24gYW55QWN0aW9uIDogZ3JvdXAuZ2V0QW55QWN0aW9ucygpKSB7CisJCQkJZ3JhbnRlZC5hZGQobmV3IFBlcm1pc3Npb24oZ3JvdXAsIGNsYXMsIGFueUFjdGlvbikpOworCQkJfQorCQl9CisJCWVsc2UgeyAKKwkJCS8vIC0tLSBldmVyeSBhdXRob3JpemF0aW9uIGV4cGxpeml0IC0tLQorCQkJZm9yIChBY3Rpb24gYWN0aW9uIDogYWN0aW9ucykgeworCQkJCWdyYW50ZWQuYWRkKG5ldyBQZXJtaXNzaW9uKGdyb3VwLCBjbGFzLCBhY3Rpb24pKTsKKwkJCX0KKwkJfQorCQlyZXR1cm4gZ3JhbnRlZDsKKwl9CisJCisJLyoqCisJICogR3JhbnRlZC4KKwkgKgorCSAqIEBwYXJhbSBncm91cCB0aGUgZ3JvdXAKKwkgKiBAcGFyYW0gY2xhcyB0aGUgY2xhcworCSAqIEBwYXJhbSBhdHRyaWJ1dGUgdGhlIGF0dHJpYnV0ZQorCSAqIEBwYXJhbSBhY3Rpb25zIHRoZSBhY3Rpb25zCisJICogQHJldHVybiB0aGUgc2V0cyB0aGUKKwkgKi8KKwlwdWJsaWMgc3RhdGljIGZpbmFsIFNldDxQZXJtaXNzaW9uPiBncmFudGVkKEdyb3VwIGdyb3VwLCBTdHJpbmcgY2xhcywgU3RyaW5nIGF0dHJpYnV0ZSwgQWN0aW9uLi4uIGFjdGlvbnMpIHsKKwkJU2V0PFBlcm1pc3Npb24+IGdyYW50ZWQgPSBuZXcgSGFzaFNldDw+KCk7CisJCWZvciAoQWN0aW9uIGFjdGlvbiA6IGFjdGlvbnMpIHsKKwkJCS8vIC0tLSBpZiB0aGUgYWN0aW9uIGhhcyBhdXRvIGdyYW50ZWQgYWN0aW9ucyAtLS0KKwkJCWlmICAoYWN0aW9uLmhhc0F1dG9HcmFudGVkQWN0aW9ucygpKSB7CisJCQkJZm9yIChBY3Rpb24gYXV0b0dyYW50ZWRBY3Rpb24gOiBhY3Rpb24uZ2V0QXV0b0dyYW50ZWRBY3Rpb25zKCkpIHsKKwkJCQkJZ3JhbnRlZC5hZGQobmV3IFBlcm1pc3Npb24oVHlwZS5HUkFOVCwgZ3JvdXAsIGNsYXMsIGF0dHJpYnV0ZSwgYXV0b0dyYW50ZWRBY3Rpb24pKTsKKwkJCQl9CisJCQl9CisJCQkvLyAtLS0gZ3JhbnQgdGhlIGFjdGlvbiBpdHNlbGYgLS0tCisJCQlncmFudGVkLmFkZChuZXcgUGVybWlzc2lvbihUeXBlLkdSQU5ULCBncm91cCwgY2xhcywgYXR0cmlidXRlLCBhY3Rpb24pKTsKKwkJfQorCQlyZXR1cm4gZ3JhbnRlZDsKKwl9CisJCisJLyoqCisJICogRGVuaWVkLgorCSAqCisJICogQHBhcmFtIGdyb3VwIHRoZSBncm91cAorCSAqIEBwYXJhbSBjbGFzIHRoZSBjbGFzCisJICogQHBhcmFtIGF0dHJpYnV0ZSB0aGUgYXR0cmlidXRlCisJICogQHBhcmFtIGFjdGlvbnMgdGhlIGFjdGlvbnMKKwkgKiBAcmV0dXJuIHRoZSBzZXRzIHRoZQorCSAqLworCXB1YmxpYyBzdGF0aWMgZmluYWwgU2V0PFBlcm1pc3Npb24+IGRlbmllZChHcm91cCBncm91cCwgU3RyaW5nIGNsYXMsIFN0cmluZyBhdHRyaWJ1dGUsIEFjdGlvbi4uLiBhY3Rpb25zKSB7CisJCVNldDxQZXJtaXNzaW9uPiBkZW5pZWQgPSBuZXcgSGFzaFNldDw+KCk7CisJCWZvciAoQWN0aW9uIGFjdGlvbiA6IGFjdGlvbnMpIHsKKwkJCS8vIC0tLSBpZiB0aGUgYWN0aW9uIGhhcyBhdXRvIGRlbmllZCBhY3Rpb25zIC0tLQorCQkJaWYgIChhY3Rpb24uaGFzQXV0b0RlbmllZEFjdGlvbnMoKSkgeworCQkJCWZvciAoQWN0aW9uIGF1dG9EZW5pZWRBY3Rpb24gOiBhY3Rpb24uZ2V0QXV0b0RlbmllZEFjdGlvbnMoKSkgeworCQkJCQlkZW5pZWQuYWRkKG5ldyBQZXJtaXNzaW9uKFR5cGUuREVOWSwgZ3JvdXAsIGNsYXMsIGF0dHJpYnV0ZSwgYXV0b0RlbmllZEFjdGlvbikpOworCQkJCX0KKwkJCX0KKwkJCS8vIC0tLSBkZW55IHRoZSBhY3Rpb24gaXRzZWxmIC0tLQorCQkJZGVuaWVkLmFkZChuZXcgUGVybWlzc2lvbihUeXBlLkRFTlksIGdyb3VwLCBjbGFzLCBhdHRyaWJ1dGUsIGFjdGlvbikpOworCQl9CisJCXJldHVybiBkZW5pZWQ7CisJfQorCQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvQWJzdHJhY3RTdWJPcmdhbml6YXRpb24uamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0Fic3RyYWN0U3ViT3JnYW5pemF0aW9uLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjM0ODRjZQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0Fic3RyYWN0U3ViT3JnYW5pemF0aW9uLmphdmEKQEAgLTAsMCArMSwxMjYgQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudXNlcmFjY2VzczsKKworaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOworaW1wb3J0IGphdmEudXRpbC5IYXNoTWFwOworaW1wb3J0IGphdmEudXRpbC5MaXN0OworaW1wb3J0IGphdmEudXRpbC5NYXA7CisKKy8vIFRPRE86IEF1dG8tZ2VuZXJhdGVkIEphdmFkb2MKKy8qKgorICogVGhlIENsYXNzIEFTdWJPcmdhbml6YXRpb24uCisgKi8KK3B1YmxpYyBjbGFzcyBBYnN0cmFjdFN1Yk9yZ2FuaXphdGlvbiBleHRlbmRzIEFic3RyYWN0T3JnRWxlbWVudCBpbXBsZW1lbnRzIElTdWJPcmdhbml6YXRpb24geworCisJLyoqIFRoZSB0aXRsZSBvZiBhbiBvcmdhbml6YXRpb24uICovCisJcHJpdmF0ZSBTdHJpbmcgdGl0bGU7CisJLyoqIFRoZSBwb3NpdGlvbiBtYXAgb2YgYWxsIHBvc2l0aW9ucyBpbmNsdWRpbmcgb2YgaXRzIHN1YiBvcmdhbml6YXRpb25zLiAqLworCXByaXZhdGUgTWFwPFN0cmluZywgSVBvc2l0aW9uPiBwb3NpdGlvbk1hcCA9IG5ldyBIYXNoTWFwPFN0cmluZywgSVBvc2l0aW9uPigpOworCS8qKgorCSAqIFRoZSBwb3NpdGlvbiBtYXAgb25seSBvZiB0aGUgb3duIHBvc2l0aW9ucyB3aXRob3V0IGl0cyBzdWIgb3JnYW5pemF0aW9ucworCSAqIC4KKwkgKi8KKwlwcml2YXRlIE1hcDxTdHJpbmcsIElQb3NpdGlvbj4gb3duUG9zaXRpb25NYXAgPSBuZXcgSGFzaE1hcDxTdHJpbmcsIElQb3NpdGlvbj4oKTsKKwkvKiogVGhlIHN1YiBvcmdhbml6YXRpb24gbWFwLiAqLworCXByaXZhdGUgTWFwPFN0cmluZywgSVN1Yk9yZ2FuaXphdGlvbj4gc3ViT3JnTWFwID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBJU3ViT3JnYW5pemF0aW9uPigpOworCisJLyoKKwkgKiAobm9uLUphdmFkb2MpCisJICogCisJICogQHNlZQorCSAqIG9yZy5lY2xpcHNlLm9zYnAuYXV0aGVudGljYXRpb24ucHJvdmlkZXIuSVN1Yk9yZ2FuaXphdGlvbiNnZXRGaWx0ZXJWYWx1ZUxpc3QKKwkgKiAoKQorCSAqLworCUBPdmVycmlkZQorCXB1YmxpYyBMaXN0PFN0cmluZz4gZ2V0RmlsdGVyVmFsdWVMaXN0KCkgeworCQlyZXR1cm4gbnVsbDsKKwl9CisKKwkvKioKKwkgKiBHZXRzIHRoZSB0aXRsZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHRpdGxlCisJICovCisJcHVibGljIFN0cmluZyBnZXRUaXRsZSgpIHsKKwkJcmV0dXJuIHRpdGxlOworCX0KKworCS8qKgorCSAqIFNldHMgdGhlIHRpdGxlLgorCSAqCisJICogQHBhcmFtIHRpdGxlCisJICogICAgICAgICAgICB0aGUgbmV3IHRpdGxlCisJICovCisJcHVibGljIHZvaWQgc2V0VGl0bGUoU3RyaW5nIHRpdGxlKSB7CisJCXRoaXMudGl0bGUgPSB0aXRsZTsKKwl9CisKKwkvKgorCSAqIChub24tSmF2YWRvYykKKwkgKiAKKwkgKiBAc2VlCisJICogb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudXNlcmFjY2Vzcy5JT3JnYW5pemF0aW9uU2VydmljZSNnZXRQb3NpdGlvbihqYXZhCisJICogLmxhbmcuU3RyaW5nKQorCSAqLworCUBPdmVycmlkZQorCXB1YmxpYyBJUG9zaXRpb24gZ2V0UG9zaXRpb24oU3RyaW5nIG5hbWUpIHsKKwkJYWRkU3ViT3JnUG9zaXRpb25zKCk7CisJCXJldHVybiBwb3NpdGlvbk1hcC5nZXQobmFtZSk7CisJfQorCisJLyoKKwkgKiAobm9uLUphdmFkb2MpCisJICogCisJICogQHNlZQorCSAqIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3MuSU9yZ2FuaXphdGlvblNlcnZpY2UjZ2V0UG9zaXRpb25zKCkKKwkgKi8KKwlAT3ZlcnJpZGUKKwlmaW5hbCBwdWJsaWMgQ29sbGVjdGlvbjxJUG9zaXRpb24+IGdldFBvc2l0aW9ucygpIHsKKwkJYWRkU3ViT3JnUG9zaXRpb25zKCk7CisJCXJldHVybiBwb3NpdGlvbk1hcC52YWx1ZXMoKTsKKwl9CisKKwkvKioKKwkgKiBNYWludGFpbnMgdGhlIHBvc2l0aW9uIG1hcCB1cCB0byBkYXRlLgorCSAqLworCXByaXZhdGUgdm9pZCBhZGRTdWJPcmdQb3NpdGlvbnMoKSB7CisJCWZvciAoSVN1Yk9yZ2FuaXphdGlvbiBzdWJPcmcgOiBnZXRTdWJPcmdhbml6YXRpb25zKCkpIHsKKwkJCWlmKHN1Yk9yZyBpbnN0YW5jZW9mIEFic3RyYWN0U3ViT3JnYW5pemF0aW9uKSB7CisJCQkJKChBYnN0cmFjdFN1Yk9yZ2FuaXphdGlvbilzdWJPcmcpLmFkZFN1Yk9yZ1Bvc2l0aW9ucygpOworCQkJfQorCQkJZm9yIChJUG9zaXRpb24gc3ViT3JnUG9zaXRpb24gOiBzdWJPcmcuZ2V0T3duUG9zaXRpb25zKCkpIHsKKwkJCQlwb3NpdGlvbk1hcC5wdXQoc3ViT3JnUG9zaXRpb24uZ2V0TmFtZSgpLCBzdWJPcmdQb3NpdGlvbik7CisJCQl9CisJCX0KKwl9CisKKwlAT3ZlcnJpZGUKKwlmaW5hbCBwdWJsaWMgQ29sbGVjdGlvbjxJUG9zaXRpb24+IGdldE93blBvc2l0aW9ucygpIHsKKwkJcmV0dXJuIG93blBvc2l0aW9uTWFwLnZhbHVlcygpOworCX0KKworCWZpbmFsIHB1YmxpYyB2b2lkIHNldFBvc2l0aW9uKElQb3NpdGlvbiBwb3NpdGlvbikgeworCQlwb3NpdGlvbk1hcC5wdXQocG9zaXRpb24uZ2V0TmFtZSgpLCBwb3NpdGlvbik7CisJCW93blBvc2l0aW9uTWFwLnB1dChwb3NpdGlvbi5nZXROYW1lKCksIHBvc2l0aW9uKTsKKwl9CisKKwlmaW5hbCBwdWJsaWMgQ29sbGVjdGlvbjxJU3ViT3JnYW5pemF0aW9uPiBnZXRTdWJPcmdhbml6YXRpb25zKCkgeworCQlyZXR1cm4gc3ViT3JnTWFwLnZhbHVlcygpOworCX0KKworCXB1YmxpYyB2b2lkIHNldFN1Yk9yZ2FuaXphdGlvbihJU3ViT3JnYW5pemF0aW9uIHN1Yk9yZykgeworCQlzdWJPcmdNYXAucHV0KHN1Yk9yZy5nZXROYW1lKCksIHN1Yk9yZyk7CisJfQorCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvdXNlcmFjY2Vzcy9JQmxpcFByb2Nlc3NQZXJtaXNzaW9ucy5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvSUJsaXBQcm9jZXNzUGVybWlzc2lvbnMuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hMzE4ZWI4Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvSUJsaXBQcm9jZXNzUGVybWlzc2lvbnMuamF2YQpAQCAtMCwwICsxLDM0IEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3M7CisKK2ltcG9ydCBqYXZhLnV0aWwuTGlzdDsKKworLyoqCisgKiAgQ29udGFpbmVyIHdpdGggYWxsIGJsaXAgcHJvY2VzcyBwZXJtaXNzaW9ucy4KKyAqICA8YnI+CisgKiAgQWxsIGV4aXN0aW5nIHJvbGVzIGZyb20gYXV0aG9yaXphdGlvbiBhbmQgYWxsIG1lbnRpb25lZCBibGlwcyBhcmUgaW5zcGVjdGVkLgorICovCitwdWJsaWMgaW50ZXJmYWNlIElCbGlwUHJvY2Vzc1Blcm1pc3Npb25zIHsKKwkvKioKKwkgKiAgQHBhcmFtICBibGlwUHJvY2Vzc05hbWUgICAgIHRoZSBibGlwIHByb2Nlc3MgcmVxdWVzdGVkCisJICogIEByZXR1cm4gbGlzdCBvZiBzdHJpbmdzIGNvbnRhaW5pbmcgYWxsIHJvbGVzLCB3aGljaCBjYW4gc3RhcnQgdGhlIHByb2Nlc3MKKwkgKi8KKwlMaXN0PFN0cmluZz4gZ2V0UHJvY2Vzc1N0YXJ0YWJsZVJvbGVzKFN0cmluZyBibGlwUHJvY2Vzc05hbWUpOworCS8qKgorCSAqICBAcGFyYW0gIGJsaXBQcm9jZXNzTmFtZSAgICAgdGhlIGJsaXAgcHJvY2VzcyByZXF1ZXN0ZWQKKwkgKiAgQHBhcmFtICBibGlwSHVtYW5UYXNrTmFtZSAgIHRoZSBibGlwIGh1bWFuIHRhc2sgcmVxdWVzdGVkCisJICogIEByZXR1cm4gbGlzdCBvZiBzdHJpbmdzIGNvbnRhaW5pbmcgYWxsIHJvbGVzLCB3aGljaCBjYW4gc3RhcnQgdGhlIHByb2Nlc3MKKwkgKi8KKwlMaXN0PFN0cmluZz4gZ2V0SHVtYW5UYXNrRXhlY3V0YWJsZVJvbGVzKFN0cmluZyBibGlwUHJvY2Vzc05hbWUsIFN0cmluZyBibGlwSHVtYW5UYXNrTmFtZSk7Cit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvdXNlcmFjY2Vzcy9JT3JnRWxlbWVudC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvSU9yZ0VsZW1lbnQuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45ZTBlNTM5Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvSU9yZ0VsZW1lbnQuamF2YQpAQCAtMCwwICsxLDYyIEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3M7CisKKy8vIFRPRE86IEF1dG8tZ2VuZXJhdGVkIEphdmFkb2MKKy8qKgorICogVGhlIEludGVyZmFjZSBJUG9zaXRpb24uCisgKi8KK3B1YmxpYyBpbnRlcmZhY2UgSU9yZ0VsZW1lbnQgeworCisJLyoqCisJICogR2V0cyB0aGUgbmFtZS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIG5hbWUKKwkgKi8KKwlTdHJpbmcgZ2V0TmFtZSgpOworCisJLyoqCisJICogQ2hlY2tzIGZvciBzdXBlcmlvci4KKwkgKgorCSAqIEByZXR1cm4gdHJ1ZSwgaWYgc3VjY2Vzc2Z1bAorCSAqLworCWJvb2xlYW4gaGFzU3VwZXJpb3IoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIHN1cGVyaW9yLgorCSAqCisJICogQHJldHVybiB0aGUgc3VwZXJpb3IKKwkgKi8KKwlTdHJpbmcgZ2V0U3VwZXJpb3IoKTsKKworCS8qKgorCSAqIENoZWNrcyBmb3Igcm9vdCBub2RlLgorCSAqCisJICogQHJldHVybiB0cnVlLCBpZiBzdWNjZXNzZnVsCisJICovCisJYm9vbGVhbiBoYXNSb290Tm9kZSgpOworCisJLyoqCisJICogR2V0cyB0aGUgcm9vdCBub2RlLgorCSAqCisJICogQHJldHVybiB0aGUgcm9vdCBub2RlCisJICovCisJU3RyaW5nIGdldFJvb3ROb2RlKCk7CisJCisJLyoqCisJICogR2V0cyB0aGUgb3JnYW5pemF0aW9uIHRoZSBub2RlIGJlbG9uZ3MgdG8uCisJICoKKwkgKiBAcmV0dXJuIHRoZSBvcmdhbml6YXRpb24KKwkgKi8KKwlJU3ViT3JnYW5pemF0aW9uIGdldE9yZ2FuaXphdGlvbigpOworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvSU9yZ2FuaXphdGlvblNlcnZpY2UuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0lPcmdhbml6YXRpb25TZXJ2aWNlLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTQxYTZmZgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0lPcmdhbml6YXRpb25TZXJ2aWNlLmphdmEKQEAgLTAsMCArMSw2MSBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS51c2VyYWNjZXNzOworCitpbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb247CisKKy8vIFRPRE86IEF1dG8tZ2VuZXJhdGVkIEphdmFkb2MKKy8qKgorICogVGhlIEludGVyZmFjZSBJT3JnYW5pemF0aW9uU2VydmljZS4KKyAqLworcHVibGljIGludGVyZmFjZSBJT3JnYW5pemF0aW9uU2VydmljZSB7CisJCisJLyoqCisJICogR2V0cyB0aGUgb3JnYW5pemF0aW9uLgorCSAqCisJICogQHBhcmFtIG5hbWUgdGhlIG5hbWUKKwkgKiBAcmV0dXJuIHRoZSBvcmdhbml6YXRpb24KKwkgKi8KKwlBYnN0cmFjdFN1Yk9yZ2FuaXphdGlvbiBnZXRPcmdhbml6YXRpb24oZmluYWwgU3RyaW5nIG5hbWUpOworCQorCS8qKgorCSAqIEdldHMgdGhlIG9yZ2FuaXphdGlvbnMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBvcmdhbml6YXRpb25zCisJICovCisJQ29sbGVjdGlvbjxBYnN0cmFjdFN1Yk9yZ2FuaXphdGlvbj4gZ2V0T3JnYW5pemF0aW9ucygpOworCQorCS8qKgorCSAqIEdldHMgdGhlIG9yZ2FuaXphdGlvbiBuYW1lcy4KKwkgKgorCSAqIEByZXR1cm4gdGhlIG9yZ2FuaXphdGlvbiBuYW1lcworCSAqLworCUNvbGxlY3Rpb248U3RyaW5nPiBnZXRPcmdhbml6YXRpb25OYW1lcygpOworCQorCS8qKgorCSAqIEdldHMgYWxsIGRlZmluZWQgcm9sZXMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSByb2xlcworCSAqLworCUNvbGxlY3Rpb248U3RyaW5nPiBnZXRSb2xlcygpOworCQorCS8qKgorCSAqIEByZXR1cm4gaW5zdGFuY2UgY29udGFpbmluZyBhbGwgYmxpcCBwcm9jZXNzIHBlcm1pc3Npb25zCisJICovCisJSUJsaXBQcm9jZXNzUGVybWlzc2lvbnMgZ2V0QmxpcFByb2Nlc3NQZXJtaXNzaW9ucygpOworCQorCS8qKgorCSAqIFJlbG9hZHMgdGhlIG1vZGVscyBhbmQgcmVmcmVzaGVzIGludGVybmFsIHN0cnVjdHVyZXMuCisJICovCisJdm9pZCByZWxvYWQoKTsKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0lQZXJtaXNzaW9uTGlzdC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvSVBlcm1pc3Npb25MaXN0LmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjUxMzBlOQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0lQZXJtaXNzaW9uTGlzdC5qYXZhCkBAIC0wLDAgKzEsNDMgQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudXNlcmFjY2VzczsKKworaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOworaW1wb3J0IGphdmEudXRpbC5TZXQ7CisKKy8vIFRPRE86IEF1dG8tZ2VuZXJhdGVkIEphdmFkb2MKKy8qKgorICogVGhlIEludGVyZmFjZSBJUGVybWlzc2lvbkxpc3QuCisgKi8KK3B1YmxpYyBpbnRlcmZhY2UgSVBlcm1pc3Npb25MaXN0IHsKKworCS8qKiBUaGUgQ29uc3RhbnQgTkVHQVRJVkVfUE9TVEZJWC4gKi8KKwlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBORUdBVElWRV9QT1NURklYID0gIl9GQUxTRSI7CisJCisJLyoqCisJICogU2V0cyB0aGUuCisJICoKKwkgKiBAcGFyYW0gcm9sZXMgdGhlIHJvbGVzCisJICogQHBhcmFtIGF1dGhvcml6YXRpb25TZXJ2aWNlcyB0aGUgYXV0aG9yaXphdGlvbiBzZXJ2aWNlcworCSAqIEByZXR1cm4gdGhlIGkgcGVybWlzc2lvbiBsaXN0CisJICovCisJSVBlcm1pc3Npb25MaXN0IHNldChDb2xsZWN0aW9uPFN0cmluZz4gcm9sZXMsIEFic3RyYWN0QXV0aG9yaXphdGlvbiBhdXRob3JpemF0aW9uU2VydmljZSk7CisJCisJLyoqCisJICogR2V0cyB0aGUgcGVybWlzc2lvbnMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBwZXJtaXNzaW9ucworCSAqLworCVNldDxTdHJpbmc+IGdldFBlcm1pc3Npb25zKCk7CisJCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvdXNlcmFjY2Vzcy9JUG9zaXRpb24uamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0lQb3NpdGlvbi5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg3ZjM4MDAKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvdXNlcmFjY2Vzcy9JUG9zaXRpb24uamF2YQpAQCAtMCwwICsxLDEyIEBACitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3M7CisKK3B1YmxpYyBpbnRlcmZhY2UgSVBvc2l0aW9uIGV4dGVuZHMgSU9yZ0VsZW1lbnQgeworCisJLyoqCisJICogR2V0cyB0aGUgcGVybWlzc2lvbiBsaXN0LgorCSAqCisJICogQHJldHVybiB0aGUgcGVybWlzc2lvbiBsaXN0CisJICovCisJSVBlcm1pc3Npb25MaXN0IGdldFBlcm1pc3Npb25MaXN0KCk7CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0lTdWJPcmdhbml6YXRpb24uamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0lTdWJPcmdhbml6YXRpb24uamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44YzUxZGQxCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvSVN1Yk9yZ2FuaXphdGlvbi5qYXZhCkBAIC0wLDAgKzEsNzkgQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudXNlcmFjY2VzczsKKworaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uOworCisvLyBUT0RPOiBBdXRvLWdlbmVyYXRlZCBKYXZhZG9jCisvKioKKyAqIFRoZSBJbnRlcmZhY2UgSVN1Yk9yZ2FuaXphdGlvbi4KKyAqLworQFN1cHByZXNzV2FybmluZ3MoImFsbCIpCitwdWJsaWMgaW50ZXJmYWNlIElTdWJPcmdhbml6YXRpb24gZXh0ZW5kcyBJT3JnRWxlbWVudCB7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBmaWx0ZXIgdmFsdWUgbGlzdC4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGZpbHRlciB2YWx1ZSBsaXN0CisJICovCisJcHVibGljIGphdmEudXRpbC5MaXN0IGdldEZpbHRlclZhbHVlTGlzdCgpOworCisJLyoqCisJICogR2V0cyB0aGUgcG9zaXRpb24gbm9kZS4KKwkgKgorCSAqIEBwYXJhbSBuYW1lCisJICogICAgICAgICAgICB0aGUgbmFtZQorCSAqIEByZXR1cm4gdGhlIHBvc2l0aW9uIG5vZGUKKwkgKi8KKwlJUG9zaXRpb24gZ2V0UG9zaXRpb24oZmluYWwgU3RyaW5nIG5hbWUpOworCisJLyoqCisJICogU2V0cyB0aGUgcG9zaXRpb24gbm9kZS4KKwkgKgorCSAqIEBwYXJhbSBuYW1lCisJICogICAgICAgICAgICB0aGUgbmFtZQorCSAqIEByZXR1cm4gdGhlIHBvc2l0aW9uIG5vZGUKKwkgKi8KKwl2b2lkIHNldFBvc2l0aW9uKElQb3NpdGlvbiBwb3NpdGlvbik7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBwb3NpdGlvbiBub2RlcyBpbmNsdWRpbmcgaXRzIHN1YiBvcmdhbml6YXRpb25zLgorCSAqCisJICogQHJldHVybiB0aGUgcG9zaXRpb24gbm9kZXMKKwkgKi8KKwlDb2xsZWN0aW9uPElQb3NpdGlvbj4gZ2V0UG9zaXRpb25zKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBwb3NpdGlvbiBub2RlcyB3aXRob3V0IGl0cyBzdWIgb3JnYW5pemF0aW9ucy4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHBvc2l0aW9uIG5vZGVzCisJICovCisJQ29sbGVjdGlvbjxJUG9zaXRpb24+IGdldE93blBvc2l0aW9ucygpOworCisJLyoqCisJICogZ2V0cyB0aGUgc3ViIG9yZ2FuaXphdGlvbnMuCisJICogCisJICogQHJldHVybiB0aGUgc3ViIG9yZ2FuaXphdGlvbnMKKwkgKi8KKwlDb2xsZWN0aW9uPElTdWJPcmdhbml6YXRpb24+IGdldFN1Yk9yZ2FuaXphdGlvbnMoKTsKKworCS8qKgorCSAqIFNldHMgdGhlIHN1YiBvcmdhbml6YXRpb24uCisJICoKKwkgKiBAcGFyYW0gc3ViT3JnCisJICogICAgICAgICAgICB0aGUgc3ViIG9yZ2FuaXphdGlvbgorCSAqIEByZXR1cm4gdGhlIHBvc2l0aW9uIG5vZGUKKwkgKi8KKwl2b2lkIHNldFN1Yk9yZ2FuaXphdGlvbihJU3ViT3JnYW5pemF0aW9uIHN1Yk9yZyk7CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0lVc2VyQWNjZXNzU2VydmljZS5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJhY2Nlc3MvSVVzZXJBY2Nlc3NTZXJ2aWNlLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjFiYTRiNgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2FwaS91c2VyYWNjZXNzL0lVc2VyQWNjZXNzU2VydmljZS5qYXZhCkBAIC0wLDAgKzEsNDUxIEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3M7CisKK2ltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbjsKK2ltcG9ydCBqYXZhLnV0aWwuTWFwOworaW1wb3J0IGphdmEudXRpbC5TZXQ7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5jb21tb24uZGF0YXR5cGVzLklEdG87CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkuY29tcGxleGRhdGFjb250YWluZXIuSUNvbXBsZXhEYXRhQ29udGFpbmVyOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLnVzZXJhY2Nlc3MuQWJzdHJhY3RBdXRob3JpemF0aW9uLlBlcm1pc3Npb247CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC51aS5hcGkudXNlcmFjY2Vzcy5BYnN0cmFjdEF1dGhvcml6YXRpb24uUGVybWlzc2lvblJlc3VsdDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS51c2VyZmlsdGVyLlVzZXJGaWx0ZXJNYXA7CisKKy8vIFRPRE86IEF1dG8tZ2VuZXJhdGVkIEphdmFkb2MKKy8qKgorICogVGhlIEludGVyZmFjZSBJVXNlckFjY2Vzc1NlcnZpY2UuCisgKi8KK3B1YmxpYyBpbnRlcmZhY2UgSVVzZXJBY2Nlc3NTZXJ2aWNlIGV4dGVuZHMgSUNvbXBsZXhEYXRhQ29udGFpbmVyIHsKKworCXB1YmxpYyBmaW5hbCBTdHJpbmcgQURNSU5JU1RSQVRPUiA9ICJBZG1pbmlzdHJhdG9yIjsKKwkvLyBpbiBjYXNlIHdlIGhhdmUgbm8gb3JnYW5pemF0aW9uYWwgaW5mb3JtYXRpb24KKwlwdWJsaWMgZmluYWwgU3RyaW5nIERFRkFVTFRVU0VSUk9MRSA9ICJVc2VycyI7CisJcHVibGljIGZpbmFsIFN0cmluZyBERUZBVUxUQURNSU5ST0xFID0gIkFkbWlucyI7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBhdXRob3JpemF0aW9ucy4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGF1dGhvcml6YXRpb25zCisJICovCisJT2JqZWN0IGdldEF1dGhvcml6YXRpb25zKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSB1c2VyLgorCSAqCisJICogQHJldHVybiB0aGUgdXNlcgorCSAqLworCUlEdG8gZ2V0VXNlcigpOworCisJLyoqCisJICogR2V0cyB0aGUgcHJvZmlsZWltYWdlIGlkLgorCSAqCisJICogQHJldHVybiB0aGUgcHJvZmlsZWltYWdlIGlkCisJICovCisJU3RyaW5nIGdldFByb2ZpbGVpbWFnZUlkKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBpZC4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGlkCisJICovCisJU3RyaW5nIGdldElkKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBwb3NpdGlvbiBuYW1lLgorCSAqCisJICogQHJldHVybiB0aGUgcG9zaXRpb24gbmFtZQorCSAqLworCVN0cmluZyBnZXRQb3NpdGlvbk5hbWUoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGVtYWlsLgorCSAqCisJICogQHJldHVybiB0aGUgZW1haWwKKwkgKi8KKwlTdHJpbmcgZ2V0RW1haWwoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIHBvc2l0aW9uLgorCSAqCisJICogQHJldHVybiB0aGUgcG9zaXRpb24KKwkgKi8KKwlBYnN0cmFjdFBvc2l0aW9uIGdldFBvc2l0aW9uKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBwZXJzcGVjdGl2ZSBpZC4KKwkgKgorCSAqIEByZXR1cm4gdGhlIHBlcnNwZWN0aXZlIGlkCisJICovCisJU3RyaW5nIGdldFBlcnNwZWN0aXZlKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBleHRyYSBwYXNzd29yZC4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGV4dHJhIHBhc3N3b3JkCisJICovCisJU3RyaW5nIGdldEV4dHJhUGFzc3dvcmQoKTsKKworCS8qKgorCSAqIENoZWNrcyBpZiB0aGUgcGFzc3dvcmQgaXMgcmVzZXQuCisJICoKKwkgKiBAcmV0dXJuIHRydWUsIGlmIHRoZSBwYXNzd29yZCBpcyByZXNldC4KKwkgKi8KKwlib29sZWFuIGlzUGFzc3dvcmRSZXNldCgpOworCisJLyoqCisJICogR2V0cyB0aGUgcm9sZXMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSByb2xlcworCSAqLworCUNvbGxlY3Rpb248U3RyaW5nPiBnZXRSb2xlcygpOworCisJLyoqCisJICogR2V0cyB0aGUgcGVybWlzc2lvbnMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBwZXJtaXNzaW9ucworCSAqLworCUlQZXJtaXNzaW9uTGlzdCBnZXRQZXJtaXNzaW9ucygpOworCisJLyoqCisJICogQ2hlY2tzIGlmIGlzIHBlcm1pdHRlZC4KKwkgKgorCSAqIEBwYXJhbSBwZXJtaXNzaW9uCisJICogICAgICAgICAgICB0aGUgcGVybWlzc2lvbgorCSAqIEByZXR1cm4gdGhlIHBlcm1pc3Npb24gcmVzdWx0CisJICovCisJUGVybWlzc2lvblJlc3VsdCBpc1Blcm1pdHRlZChQZXJtaXNzaW9uIHBlcm1pc3Npb24pOworCisJLyoqCisJICogQ2hlY2tzIGlmIGlzIGF1dGhlbnRpY2F0ZWQuCisJICoKKwkgKiBAcmV0dXJuIHRydWUsIGlmIGlzIGF1dGhlbnRpY2F0ZWQKKwkgKi8KKwlib29sZWFuIGlzQXV0aGVudGljYXRlZCgpOworCisJLyoqCisJICogQXV0aGVudGljYXRlLgorCSAqCisJICogQHBhcmFtIHBvcnRhbAorCSAqICAgICAgICAgICAgdGhlIHBvcnRhbAorCSAqIEBwYXJhbSB1c2VybmFtZQorCSAqICAgICAgICAgICAgdGhlIHVzZXJuYW1lCisJICogQHBhcmFtIHBhc3N3b3JkCisJICogICAgICAgICAgICB0aGUgcGFzc3dvcmQKKwkgKiBAcmV0dXJuIHRydWUsIGlmIHN1Y2Nlc3NmdWwKKwkgKi8KKwlib29sZWFuIGF1dGhlbnRpY2F0ZShTdHJpbmcgcG9ydGFsLCBTdHJpbmcgdXNlcm5hbWUsIFN0cmluZyBwYXNzd29yZCk7CisKKwkvKioKKwkgKiBBdXRoZW50aWNhdGUuCisJICoKKwkgKiBAcGFyYW0gcG9ydGFsSWQKKwkgKiAgICAgICAgICAgIHRoZSBwb3J0YWwgaWQKKwkgKiBAcGFyYW0gdXNlcm5hbWUKKwkgKiAgICAgICAgICAgIHRoZSB1c2VybmFtZQorCSAqIEBwYXJhbSBwYXNzd29yZAorCSAqICAgICAgICAgICAgdGhlIHBhc3N3b3JkCisJICogQHJldHVybiB0cnVlLCBpZiBzdWNjZXNzZnVsCisJICovCisJYm9vbGVhbiBhdXRoZW50aWNhdGUoaW50IHBvcnRhbElkLCBTdHJpbmcgdXNlcm5hbWUsIFN0cmluZyBwYXNzd29yZCk7CisKKwkvKioKKwkgKiBBdXRoZW50aWNhdGUuCisJICoKKwkgKiBAcGFyYW0gdXNlcm5hbWUKKwkgKiAgICAgICAgICAgIHRoZSB1c2VybmFtZQorCSAqIEBwYXJhbSBwYXNzd29yZAorCSAqICAgICAgICAgICAgdGhlIHBhc3N3b3JkCisJICogQHJldHVybiB0cnVlLCBpZiBzdWNjZXNzZnVsCisJICovCisJYm9vbGVhbiBhdXRoZW50aWNhdGUoU3RyaW5nIHVzZXJuYW1lLCBTdHJpbmcgcGFzc3dvcmQpOworCisJLyoqCisJICogU2V0cyB0aGUgc2Vzc2lvbiBhdHRyaWJ1dGUuCisJICoKKwkgKiBAcGFyYW0ga2V5CisJICogICAgICAgICAgICB0aGUga2V5CisJICogQHBhcmFtIHZhbHVlCisJICogICAgICAgICAgICB0aGUgdmFsdWUKKwkgKi8KKwl2b2lkIHNldFNlc3Npb25BdHRyaWJ1dGUoU3RyaW5nIGtleSwgT2JqZWN0IHZhbHVlKTsKKworCS8qKgorCSAqIEdldHMgdGhlIHNlc3Npb24gYXR0cmlidXRlLgorCSAqCisJICogQHBhcmFtIGtleQorCSAqICAgICAgICAgICAgdGhlIGtleQorCSAqIEByZXR1cm4gdGhlIHNlc3Npb24gYXR0cmlidXRlCisJICovCisJT2JqZWN0IGdldFNlc3Npb25BdHRyaWJ1dGUoU3RyaW5nIGtleSk7CisKKwkvKioKKwkgKiBMb2dvdXQuCisJICovCisJdm9pZCBsb2dvdXQoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGFsbCB1c2Vycy4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGFsbCB1c2VycworCSAqLworCVNldDxTdHJpbmc+IGdldEFsbFVzZXJzKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBhbGwgdXNlcnMgcG9zaXRpb25zLgorCSAqCisJICogQHJldHVybiB0aGUgYWxsIHVzZXJzIHBvc2l0aW9ucworCSAqLworCU1hcDxTdHJpbmcsIFN0cmluZz4gZ2V0QWxsVXNlcnNQb3NpdGlvbnMoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGFsbCBlbWFpbHMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBhbGwgZW1haWxzCisJICovCisJU2V0PFN0cmluZz4gZ2V0QWxsRW1haWxzKCk7CisKKwkvKioKKwkgKiBGaW5kIHVzZXJzIGZvciBwb3NpdGlvbi4KKwkgKgorCSAqIEBwYXJhbSBvcmdOb2RlCisJICogICAgICAgICAgICB0aGUgb3JnIG5vZGUKKwkgKiBAcmV0dXJuIHRoZSBzZXRzIHRoZQorCSAqLworCVNldDxTdHJpbmc+IGZpbmRVc2Vyc0ZvclBvc2l0aW9uKFN0cmluZyBvcmdOb2RlKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGFsbCBwb3NpdGlvbnMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBhbGwgcG9zaXRpb25zCisJICovCisJU2V0PEFic3RyYWN0UG9zaXRpb24+IGdldEFsbFBvc2l0aW9ucygpOworCisJLyoqCisJICogRmluZCB1c2VyIGFjY291bnQuCisJICoKKwkgKiBAcGFyYW0gdXNlcm5hbWUKKwkgKiAgICAgICAgICAgIHRoZSB1c2VybmFtZQorCSAqIEByZXR1cm4gdGhlIHVzZXIgYWNjb3VudCBkdG8KKwkgKi8KKwlJRHRvIGZpbmRVc2VyQWNjb3VudChTdHJpbmcgdXNlcm5hbWUpOworCisJLyoqCisJICogRmluZCBwb3NpdGlvbiBmb3IgdXNlci4KKwkgKgorCSAqIEBwYXJhbSB1c2VybmFtZQorCSAqICAgICAgICAgICAgdGhlIHVzZXJuYW1lCisJICogQHJldHVybiB0aGUgYSBwb3NpdGlvbgorCSAqLworCUFic3RyYWN0UG9zaXRpb24gZmluZFBvc2l0aW9uRm9yVXNlcihTdHJpbmcgdXNlcm5hbWUpOworCisJLyoqCisJICogRmluZCBwb3NpdGlvbiBmb3IgcG9zaXRpb24gbmFtZS4KKwkgKgorCSAqIEBwYXJhbSBwb3NpdGlvbk5hbWUKKwkgKiAgICAgICAgICAgIHRoZSBwb3NpdGlvbiBuYW1lCisJICogQHJldHVybiB0aGUgYSBwb3NpdGlvbgorCSAqLworCUFic3RyYWN0UG9zaXRpb24gZmluZFBvc2l0aW9uRm9yUG9zaXRpb25OYW1lKFN0cmluZyBwb3NpdGlvbk5hbWUpOworCisJLyoqCisJICogRmluZCByb2xlcyBmb3IgdXNlci4KKwkgKgorCSAqIEBwYXJhbSB1c2VybmFtZQorCSAqICAgICAgICAgICAgdGhlIHVzZXJuYW1lCisJICogQHJldHVybiB0aGUgY29sbGVjdGlvbgorCSAqLworCUNvbGxlY3Rpb248U3RyaW5nPiBmaW5kUm9sZXNGb3JVc2VyKFN0cmluZyB1c2VybmFtZSk7CisKKwkvKioKKwkgKiBGaW5kIHBlcm1pc3Npb25zIGZvciB1c2VyLgorCSAqCisJICogQHBhcmFtIHVzZXJuYW1lCisJICogICAgICAgICAgICB0aGUgdXNlcm5hbWUKKwkgKiBAcmV0dXJuIHRoZSBpIHBlcm1pc3Npb24gbGlzdAorCSAqLworCUlQZXJtaXNzaW9uTGlzdCBmaW5kUGVybWlzc2lvbnNGb3JVc2VyKFN0cmluZyB1c2VybmFtZSk7CisKKwkvKioKKwkgKiBDaGVjayB1c2VyIG5hbWUgdW5pcXVlbmVzcyBmb3IgbG9nZ2VkIGluIHVzZXJzLgorCSAqCisJICogQHBhcmFtIHVzZXJuYW1lCisJICogICAgICAgICAgICB0aGUgdXNlciBuYW1lCisJICogQHJldHVybiB0cnVlLCBpZiBzdWNjZXNzZnVsCisJICovCisJYm9vbGVhbiBjaGVja0xvZ2dlZEluVXNlcm5hbWVFeGlzdHMoU3RyaW5nIHVzZXJuYW1lKTsKKworCS8qKgorCSAqIENoZWNrIHVzZXIgbmFtZSB1bmlxdWVuZXNzIGluZGVwZW5kZW50IG9mIGEgc3VjY2Vzc2Z1bCBsb2cgaW4uCisJICoKKwkgKiBAcGFyYW0gdXNlcm5hbWUKKwkgKiAgICAgICAgICAgIHRoZSB1c2VyIG5hbWUKKwkgKiBAcmV0dXJuIHRydWUsIGlmIHN1Y2Nlc3NmdWwKKwkgKi8KKwlib29sZWFuIGNoZWNrTm90TG9nZ2VkSW5Vc2VybmFtZUV4aXN0cyhTdHJpbmcgdXNlcm5hbWUpOworCisJLyoqCisJICogQ2hlY2sgZW1haWwgdW5pcXVlbmVzcy4KKwkgKgorCSAqIEBwYXJhbSBlbWFpbAorCSAqICAgICAgICAgICAgdGhlIGVtYWlsCisJICogQHJldHVybiB0cnVlLCBpZiBzdWNjZXNzZnVsCisJICovCisJYm9vbGVhbiBjaGVja0VtYWlsRXhpc3RzKFN0cmluZyBlbWFpbCk7CisKKwkvKioKKwkgKiBMb2NrIGFjY291bnQuCisJICoKKwkgKiBAcGFyYW0gdXNlcm5hbWUKKwkgKiAgICAgICAgICAgIHRoZSB1c2VybmFtZQorCSAqIEBwYXJhbSBsb2NrZWQKKwkgKiAgICAgICAgICAgIHRoZSBsb2NrZWQKKwkgKi8KKwl2b2lkIGxvY2tBY2NvdW50KFN0cmluZyB1c2VybmFtZSwgYm9vbGVhbiBsb2NrZWQpOworCisJLyoqCisJICogRW5hYmxlIGFjY291bnQuCisJICoKKwkgKiBAcGFyYW0gdXNlcm5hbWUKKwkgKiAgICAgICAgICAgIHRoZSB1c2VybmFtZQorCSAqIEBwYXJhbSBlbmFibGVkCisJICogICAgICAgICAgICB0aGUgZW5hYmxlZAorCSAqLworCXZvaWQgZW5hYmxlQWNjb3VudChTdHJpbmcgdXNlcm5hbWUsIGJvb2xlYW4gZW5hYmxlZCk7CisKKwkvKioKKwkgKiBTZXRzIHRoZSBjb29raWUgaGFzaC4KKwkgKgorCSAqIEBwYXJhbSB1c2VybmFtZQorCSAqICAgICAgICAgICAgdGhlIHVzZXJuYW1lCisJICogQHBhcmFtIGNvb2tpZQorCSAqICAgICAgICAgICAgdGhlIGNvb2tpZQorCSAqLworCXZvaWQgc2V0Q29va2llSGFzaChTdHJpbmcgdXNlcm5hbWUsIFN0cmluZyBjb29raWUpOworCisJLyoqCisJICogQ2hlY2tzIGlmIGlzIGNvb2tpZSB2YWxpZC4KKwkgKgorCSAqIEBwYXJhbSB1c2VybmFtZQorCSAqICAgICAgICAgICAgdGhlIHVzZXJuYW1lCisJICogQHBhcmFtIGNvb2tpZQorCSAqICAgICAgICAgICAgdGhlIGNvb2tpZQorCSAqIEByZXR1cm4gdHJ1ZSwgaWYgaXMgY29va2llIHZhbGlkCisJICovCisJYm9vbGVhbiBpc0Nvb2tpZVZhbGlkKFN0cmluZyB1c2VybmFtZSwgU3RyaW5nIGNvb2tpZSk7CisKKwkvKioKKwkgKiBFbmNyeXB0IHBhc3N3b3JkLgorCSAqCisJICogQHBhcmFtIGRlY3J5cHRlZFBhc3N3b3JkCisJICogICAgICAgICAgICB0aGUgZGVjcnlwdGVkIHBhc3N3b3JkCisJICogQHJldHVybiB0aGUgc3RyaW5nCisJICovCisJU3RyaW5nIGVuY3J5cHRQYXNzd29yZChTdHJpbmcgZGVjcnlwdGVkUGFzc3dvcmQpOworCisJLyoqCisJICogQ2hlY2tzIGlmIGlzIGFjY291bnQgbG9ja2VkLgorCSAqCisJICogQHBhcmFtIHVzZXJuYW1lCisJICogICAgICAgICAgICB0aGUgdXNlcm5hbWUKKwkgKiBAcmV0dXJuIHRydWUsIGlmIGlzIGFjY291bnQgbG9ja2VkCisJICovCisJYm9vbGVhbiBpc0FjY291bnRMb2NrZWQoU3RyaW5nIHVzZXJuYW1lKTsKKworCS8qKgorCSAqIENoZWNrcyBpZiB0aGUgYWNjb3VudCBpcyBzdGlsbCBub3QgcmVnaXN0ZXJlZC4KKwkgKgorCSAqIEBwYXJhbSB1c2VybmFtZQorCSAqICAgICAgICAgICAgdGhlIHVzZXJuYW1lCisJICogQHJldHVybiB0cnVlLCB0aGUgYWNjb3VudCBpcyBzdGlsbCBub3QgcmVnaXN0ZXJlZAorCSAqLworCWJvb2xlYW4gaXNBY2NvdW50Tm90UmVnaXN0ZXJlZChTdHJpbmcgdXNlcm5hbWUpOworCisJLyoqCisJICogQ2hlY2tzIGlmIGlzIGFjY291bnQgZW5hYmxlZC4KKwkgKgorCSAqIEBwYXJhbSB1c2VybmFtZQorCSAqICAgICAgICAgICAgdGhlIHVzZXJuYW1lCisJICogQHJldHVybiB0cnVlLCBpZiBpcyBhY2NvdW50IGVuYWJsZWQKKwkgKi8KKwlib29sZWFuIGlzQWNjb3VudEVuYWJsZWQoU3RyaW5nIHVzZXJuYW1lKTsKKworCS8qKgorCSAqIEVuY3J5cHQgcGFzc3dvcmRzLgorCSAqLworCXZvaWQgZW5jcnlwdFBhc3N3b3JkcygpOworCisJLyoqCisJICogR2V0cyB0aGUgYWxsIHVzZXIgYWNjb3VudCByb2xlcy4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGFsbCB1c2VyIGFjY291bnQgcm9sZXMKKwkgKi8KKwlNYXA8U3RyaW5nLCBDb2xsZWN0aW9uPFN0cmluZz4+IGdldEFsbFVzZXJBY2NvdW50Um9sZXMoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIGxvY2FsZSB0YWcuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBsb2NhbGUgdGFnCisJICovCisJU3RyaW5nIGdldExvY2FsZVRhZygpOworCisJLyoqCisJICogR2V0cyB0aGUgbGF5b3V0aW5nIHN0cmF0ZWd5LgorCSAqCisJICogQHJldHVybiB0aGUgbGF5b3V0aW5nIHN0cmF0ZWd5CisJICovCisJU3RyaW5nIGdldExheW91dGluZ1N0cmF0ZWd5KCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSBmb2N1c2luZyBzdHJhdGVneS4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGZvY3VzaW5nIHN0cmF0ZWd5CisJICovCisJU3RyaW5nIGdldEZvY3VzaW5nU3RyYXRlZ3koKTsKKworCS8qKgorCSAqIEdldHMgdGhlIHRoZW1lLgorCSAqCisJICogQHJldHVybiB0aGUgdGhlbWUKKwkgKi8KKwlTdHJpbmcgZ2V0VGhlbWUoKTsKKwkKKwkvKioKKwkgKiBHZXRzIHRoZSBwcmludHMgdGhlIHNlcnZpY2UuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBwcmludHMgdGhlIHNlcnZpY2UKKwkgKi8KKwlTdHJpbmcgZ2V0UHJpbnRTZXJ2aWNlKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSB1c2VyIGZpbHRlciBtYXAuCisJICoKKwkgKiBAcmV0dXJuIHRoZSB1c2VyIGZpbHRlciBtYXAKKwkgKi8KKwlVc2VyRmlsdGVyTWFwIGdldFVzZXJGaWx0ZXJNYXAoKTsKKworCS8qKgorCSAqIENoZWNrcyBpZiBpcyBzdXBlcnVzZXIuCisJICoKKwkgKiBAcmV0dXJuIHRydWUsIGlmIGlzIHN1cGVydXNlcgorCSAqLworCWJvb2xlYW4gaXNTdXBlcnVzZXIoKTsKKworCS8qKgorCSAqIENoZWNrcyBpZiBpcyBzdXBlcnZpc29yLgorCSAqCisJICogQHJldHVybiB0cnVlLCBpZiBpcyBzdXBlcnZpc29yCisJICovCisJYm9vbGVhbiBpc1N1cGVydmlzb3IoKTsKKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJmaWx0ZXIvVXNlckZpbHRlck1hcC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvYXBpL3VzZXJmaWx0ZXIvVXNlckZpbHRlck1hcC5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc0Y2RiM2QKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9hcGkvdXNlcmZpbHRlci9Vc2VyRmlsdGVyTWFwLmphdmEKQEAgLTAsMCArMSw0MiBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS51c2VyZmlsdGVyOworCitpbXBvcnQgamF2YS51dGlsLkhhc2hNYXA7CitpbXBvcnQgamF2YS51dGlsLkxpc3Q7CisKK3B1YmxpYyBjbGFzcyBVc2VyRmlsdGVyTWFwIHsKKwkvKiogVGhlIGluIGZpbHRlciBtYXAuICovCisJcHJpdmF0ZSBIYXNoTWFwPFN0cmluZywgTGlzdDxTdHJpbmc+PiBpbkZpbHRlck1hcCA9IG5ldyBIYXNoTWFwPD4oKTsKKwkKKwkvKiogVGhlIG5vdCBmaWx0ZXIgbWFwLiAqLworCXByaXZhdGUgSGFzaE1hcDxTdHJpbmcsIExpc3Q8U3RyaW5nPj4gbm90RmlsdGVyTWFwID0gbmV3IEhhc2hNYXA8PigpOworCQorCS8qKgorCSAqIEdldHMgdGhlIGluIGZpbHRlciBtYXAuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBpbiBmaWx0ZXIgbWFwCisJICovCisJcHVibGljIEhhc2hNYXA8U3RyaW5nLCBMaXN0PFN0cmluZz4+IGdldEluRmlsdGVyTWFwKCkgeworCQlyZXR1cm4gaW5GaWx0ZXJNYXA7CisJfQorCQorCS8qKgorCSAqIEdldHMgdGhlIG5vdCBmaWx0ZXIgbWFwLgorCSAqCisJICogQHJldHVybiB0aGUgbm90IGZpbHRlciBtYXAKKwkgKi8KKwlwdWJsaWMgSGFzaE1hcDxTdHJpbmcsIExpc3Q8U3RyaW5nPj4gZ2V0Tm90RmlsdGVyTWFwKCkgeworCQlyZXR1cm4gbm90RmlsdGVyTWFwOworCX0KK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0Fic3RyYWN0SW5pdGlhbGl6YXRpb25MaXN0ZW5lci5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvaW5pdGlhbGl6YXRpb24vQWJzdHJhY3RJbml0aWFsaXphdGlvbkxpc3RlbmVyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWJlNjZhOAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0Fic3RyYWN0SW5pdGlhbGl6YXRpb25MaXN0ZW5lci5qYXZhCkBAIC0wLDAgKzEsODMgQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5pbml0aWFsaXphdGlvbjsKKworaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OworaW1wb3J0IGphdmEudXRpbC5TZXQ7CisKK3B1YmxpYyBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdEluaXRpYWxpemF0aW9uTGlzdGVuZXIgaW1wbGVtZW50cyBJSW5pdGlhbGl6YXRpb25MaXN0ZW5lciB7CisKKwlwcml2YXRlIElJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbiBsYXN0Tm90aWZpY2F0aW9uID0gbnVsbDsKKwkKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCByZXNlbmRMYXN0Tm90aWZpY2F0aW9uKCkgeworCQlpZgkobGFzdE5vdGlmaWNhdGlvbiBpbnN0YW5jZW9mIEluaXRpYWxpemF0aW9uRG9uZU5vdGlmaWNhdGlvbikgeworCQkJbm90aWZ5SW5pdGlhbGl6YXRpb25Eb25lKGxhc3ROb3RpZmljYXRpb24pOworCQl9CisJCWVsc2UgaWYgKGxhc3ROb3RpZmljYXRpb24gaW5zdGFuY2VvZiBJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbikgeworCQkJbm90aWZ5SW5pdGlhbGl6YXRpb25TdGVwKGxhc3ROb3RpZmljYXRpb24pOworCQl9CisJfQorCisJcHJpdmF0ZSBTZXQ8SUluaXRpYWxpemF0aW9uUHJvdmlkZXI+IGluaXRpYWxpemF0aW9uUHJvdmlkZXJzID0gbmV3IEhhc2hTZXQ8SUluaXRpYWxpemF0aW9uUHJvdmlkZXI+KCk7CisJCisJLyogKG5vbi1KYXZhZG9jKQorCSAqIEBzZWUgb3JnLmVjbGlwc2Uub3NicC51aS5pbml0aWFsaXphdGlvbi5JSW5pdGlhbGl6YXRpb25MaXN0ZW5lciNiaW5kSW5pdGlhbGl6YXRpb25Qcm92aWRlcihvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uLkFic3RyYWN0SW5pdGlhbGl6YXRpb25Qcm92aWRlcikKKwkgKi8KKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCBhZGRJbml0aWFsaXphdGlvblByb3ZpZGVyKElJbml0aWFsaXphdGlvblByb3ZpZGVyIHByb3ZpZGVyKSB7CisJCWluaXRpYWxpemF0aW9uUHJvdmlkZXJzLmFkZChwcm92aWRlcik7CisJCXByb3ZpZGVyLmFkZEluaXRpYWxpemF0aW9uTGlzdGVuZXIodGhpcyk7CisJfQorCQorCS8qIChub24tSmF2YWRvYykKKwkgKiBAc2VlIG9yZy5lY2xpcHNlLm9zYnAudWkuaW5pdGlhbGl6YXRpb24uSUluaXRpYWxpemF0aW9uTGlzdGVuZXIjdW5iaW5kSW5pdGlhbGl6YXRpb25Qcm92aWRlcihvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uLklJbml0aWFsaXphdGlvblByb3ZpZGVyKQorCSAqLworCUBPdmVycmlkZQorCXB1YmxpYyB2b2lkIHJlbW92ZUluaXRpYWxpemF0aW9uUHJvdmlkZXIoSUluaXRpYWxpemF0aW9uUHJvdmlkZXIgcHJvdmlkZXIpIHsKKwkJaW5pdGlhbGl6YXRpb25Qcm92aWRlcnMucmVtb3ZlKHByb3ZpZGVyKTsKKwkJcHJvdmlkZXIucmVtb3ZlSW5pdGlhbGl6YXRpb25MaXN0ZW5lcih0aGlzKTsKKwl9CisJCisJcHJvdGVjdGVkIHZvaWQgcmVtb3ZlQWxsSW5pdGlhbGl6YXRpb25Qcm92aWRlcnMoKSB7CisJCWZvcgkoSUluaXRpYWxpemF0aW9uUHJvdmlkZXIgcHJvdmlkZXIgOiBpbml0aWFsaXphdGlvblByb3ZpZGVycykgeworCQkJcmVtb3ZlSW5pdGlhbGl6YXRpb25Qcm92aWRlcihwcm92aWRlcik7CisJCX0KKwl9CisJCisJcHJvdGVjdGVkIGJvb2xlYW4gaGFzSW5pdGlhbGl6YXRpb25Ub0JlRG9uZSgpIHsKKwkJZm9yCShJSW5pdGlhbGl6YXRpb25Qcm92aWRlciBwcm92aWRlciA6IGluaXRpYWxpemF0aW9uUHJvdmlkZXJzKSB7CisJCQlpZgkocHJvdmlkZXIuaGFzSW5pdGlhbGl6YXRpb25Ub0JlRG9uZSgpKSB7CisJCQkJcmV0dXJuIHRydWU7CisJCQl9CisJCX0KKwkJcmV0dXJuIGZhbHNlOworCX0KKwkKKwkvKiAobm9uLUphdmFkb2MpCisJICogQHNlZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uLklJbml0aWFsaXphdGlvbkxpc3RlbmVyI25vdGlmeUluaXRpYWxpemF0aW9uU3RlcChvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uLkluaXRpYWxpemF0aW9uTm90aWZpY2F0aW9uKQorCSAqLworCUBPdmVycmlkZQorCXB1YmxpYyBzeW5jaHJvbml6ZWQgdm9pZCBub3RpZnlJbml0aWFsaXphdGlvblN0ZXAoSUluaXRpYWxpemF0aW9uTm90aWZpY2F0aW9uIG5vdGlmaWNhdGlvbikgeworCQlsYXN0Tm90aWZpY2F0aW9uID0gbm90aWZpY2F0aW9uOworCX0KKwkKKwkvKiAobm9uLUphdmFkb2MpCisJICogQHNlZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uLklJbml0aWFsaXphdGlvbkxpc3RlbmVyI25vdGlmeUluaXRpYWxpemF0aW9uRG9uZShvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uLkluaXRpYWxpemF0aW9uRG9uZU5vdGlmaWNhdGlvbikKKwkgKi8KKwlAT3ZlcnJpZGUKKwlwdWJsaWMgc3luY2hyb25pemVkIHZvaWQgbm90aWZ5SW5pdGlhbGl6YXRpb25Eb25lKElJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbiBub3RpZmljYXRpb24pIHsKKwkJbGFzdE5vdGlmaWNhdGlvbiA9IG5vdGlmaWNhdGlvbjsKKwkJLy8gdW5iaW5kSW5pdGlhbGl6YXRpb25Qcm92aWRlcihub3RpZmljYXRpb24uZ2V0SW5pdGlhbGl6YXRpb25Qcm92aWRlcigpKTsKKwl9Cit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9pbml0aWFsaXphdGlvbi9BYnN0cmFjdEluaXRpYWxpemF0aW9uUHJvdmlkZXIuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0Fic3RyYWN0SW5pdGlhbGl6YXRpb25Qcm92aWRlci5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmYzYjkwMDkKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9pbml0aWFsaXphdGlvbi9BYnN0cmFjdEluaXRpYWxpemF0aW9uUHJvdmlkZXIuamF2YQpAQCAtMCwwICsxLDY4IEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuaW5pdGlhbGl6YXRpb247CisKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaFNldDsKK2ltcG9ydCBqYXZhLnV0aWwuU2V0OworCitwdWJsaWMgYWJzdHJhY3QgY2xhc3MgQWJzdHJhY3RJbml0aWFsaXphdGlvblByb3ZpZGVyIGltcGxlbWVudHMgSUluaXRpYWxpemF0aW9uUHJvdmlkZXIgeworCisJcHJpdmF0ZSBTZXQ8QWJzdHJhY3RJbml0aWFsaXphdGlvbkxpc3RlbmVyPiBpbml0aWFsaXphdGlvbkxpc3RlbmVycyA9IG5ldyBIYXNoU2V0PEFic3RyYWN0SW5pdGlhbGl6YXRpb25MaXN0ZW5lcj4oKTsKKwkKKwkvKiAobm9uLUphdmFkb2MpCisJICogQHNlZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uLklJbml0aWFsaXphdGlvblByb3ZpZGVyI2hhc0luaXRpYWxpemF0aW9uVG9CZURvbmUoKQorCSAqLworCUBPdmVycmlkZQorCWFic3RyYWN0IHB1YmxpYyBib29sZWFuIGhhc0luaXRpYWxpemF0aW9uVG9CZURvbmUoKTsKKwkKKwlhYnN0cmFjdCBwdWJsaWMgU3RyaW5nIGdldEluaXRpYWxpemF0aW9uUHJvdmlkZXJUaXRsZSgpOworCQorCWFic3RyYWN0IHB1YmxpYyBpbnQgZ2V0SW5pdGlhbGl6YXRpb25Ub3RhbFN0ZXBzKCk7CisJCisJLyogKG5vbi1KYXZhZG9jKQorCSAqIEBzZWUgb3JnLmVjbGlwc2Uub3NicC51aS5pbml0aWFsaXphdGlvbi5JSW5pdGlhbGl6YXRpb25Qcm92aWRlciNhZGRJbml0aWFsaXphdGlvbkxpc3RlbmVyKG9yZy5lY2xpcHNlLm9zYnAudWkuaW5pdGlhbGl6YXRpb24uQWJzdHJhY3RJbml0aWFsaXphdGlvbkxpc3RlbmVyKQorCSAqLworCUBPdmVycmlkZQorCXB1YmxpYyB2b2lkIGFkZEluaXRpYWxpemF0aW9uTGlzdGVuZXIoQWJzdHJhY3RJbml0aWFsaXphdGlvbkxpc3RlbmVyIGxpc3RlbmVyKSB7CisJCWluaXRpYWxpemF0aW9uTGlzdGVuZXJzLmFkZChsaXN0ZW5lcik7CisJfQorCQorCS8qIChub24tSmF2YWRvYykKKwkgKiBAc2VlIG9yZy5lY2xpcHNlLm9zYnAudWkuaW5pdGlhbGl6YXRpb24uSUluaXRpYWxpemF0aW9uUHJvdmlkZXIjcmVtb3ZlSW5pdGlhbGl6YXRpb25MaXN0ZW5lcihvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uLkFic3RyYWN0SW5pdGlhbGl6YXRpb25MaXN0ZW5lcikKKwkgKi8KKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCByZW1vdmVJbml0aWFsaXphdGlvbkxpc3RlbmVyKElJbml0aWFsaXphdGlvbkxpc3RlbmVyIGxpc3RlbmVyKSB7CisJCWluaXRpYWxpemF0aW9uTGlzdGVuZXJzLnJlbW92ZShsaXN0ZW5lcik7CisJfQorCQorCS8qIChub24tSmF2YWRvYykKKwkgKiBAc2VlIG9yZy5lY2xpcHNlLm9zYnAudWkuaW5pdGlhbGl6YXRpb24uSUluaXRpYWxpemF0aW9uUHJvdmlkZXIjbm90aWZ5SW5pdGlhbGl6YXRpb25TdGVwKG9yZy5lY2xpcHNlLm9zYnAudWkuaW5pdGlhbGl6YXRpb24uSW5pdGlhbGl6YXRpb25Ob3RpZmljYXRpb24pCisJICovCisJQE92ZXJyaWRlCisJcHVibGljIHZvaWQgbm90aWZ5SW5pdGlhbGl6YXRpb25TdGVwKElJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbiBub3RpZmljYXRpb24pIHsKKwkJZm9yCShJSW5pdGlhbGl6YXRpb25MaXN0ZW5lciBsaXN0ZW5lciA6IGluaXRpYWxpemF0aW9uTGlzdGVuZXJzKSB7CisJCQlsaXN0ZW5lci5ub3RpZnlJbml0aWFsaXphdGlvblN0ZXAobm90aWZpY2F0aW9uKTsKKwkJfQorCX0KKwkKKwkvKiAobm9uLUphdmFkb2MpCisJICogQHNlZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uLklJbml0aWFsaXphdGlvblByb3ZpZGVyI25vdGlmeUluaXRpYWxpemF0aW9uRG9uZSgpCisJICovCisJQE92ZXJyaWRlCisJcHVibGljIHZvaWQgbm90aWZ5SW5pdGlhbGl6YXRpb25Eb25lKCkgeworCQlJbml0aWFsaXphdGlvbkRvbmVOb3RpZmljYXRpb24gbm90aWZpY2F0aW9uID0gbmV3IEluaXRpYWxpemF0aW9uRG9uZU5vdGlmaWNhdGlvbih0aGlzKTsKKwkJZm9yCShJSW5pdGlhbGl6YXRpb25MaXN0ZW5lciBsaXN0ZW5lciA6IGluaXRpYWxpemF0aW9uTGlzdGVuZXJzKSB7CisJCQlsaXN0ZW5lci5ub3RpZnlJbml0aWFsaXphdGlvbkRvbmUobm90aWZpY2F0aW9uKTsKKwkJfQorCX0KK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0lJbml0aWFsaXphdGlvbkxpc3RlbmVyLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9pbml0aWFsaXphdGlvbi9JSW5pdGlhbGl6YXRpb25MaXN0ZW5lci5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjgzNzBjM2MKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9pbml0aWFsaXphdGlvbi9JSW5pdGlhbGl6YXRpb25MaXN0ZW5lci5qYXZhCkBAIC0wLDAgKzEsMjYgQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5pbml0aWFsaXphdGlvbjsKKworcHVibGljIGludGVyZmFjZSBJSW5pdGlhbGl6YXRpb25MaXN0ZW5lciB7CisKKwlwdWJsaWMgdm9pZCBhZGRJbml0aWFsaXphdGlvblByb3ZpZGVyKElJbml0aWFsaXphdGlvblByb3ZpZGVyIHByb3ZpZGVyKTsKKworCXB1YmxpYyB2b2lkIHJlbW92ZUluaXRpYWxpemF0aW9uUHJvdmlkZXIoSUluaXRpYWxpemF0aW9uUHJvdmlkZXIgcHJvdmlkZXIpOworCisJcHVibGljIHZvaWQgbm90aWZ5SW5pdGlhbGl6YXRpb25TdGVwKElJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbiBub3RpZmljYXRpb24pOworCisJcHVibGljIHZvaWQgbm90aWZ5SW5pdGlhbGl6YXRpb25Eb25lKElJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbiBub3RpZmljYXRpb24pOworCQorCXB1YmxpYyB2b2lkIHJlc2VuZExhc3ROb3RpZmljYXRpb24oKTsKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0lJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbi5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvaW5pdGlhbGl6YXRpb24vSUluaXRpYWxpemF0aW9uTm90aWZpY2F0aW9uLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGRhODg3NAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0lJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbi5qYXZhCkBAIC0wLDAgKzEsMzYgQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5pbml0aWFsaXphdGlvbjsKKworcHVibGljIGludGVyZmFjZSBJSW5pdGlhbGl6YXRpb25Ob3RpZmljYXRpb24geworCisJcHVibGljIGFic3RyYWN0IElJbml0aWFsaXphdGlvblByb3ZpZGVyIGdldEluaXRpYWxpemF0aW9uUHJvdmlkZXIoKTsKKworCS8qKgorCSAqIEdldHMgdGhlIHJlY29tbWVuZGVkIHByb2dyZXNzIHZhbHVlLgorCSAqIAorCSAqIEl0J3MgY2FsY3VsYXRlZCBieSB0aGUgYWN0dWFsIHN0ZXBzIG51bWJlciwgdG90YWwgY291bnQgb2Ygc3RlcHMgYW5kIG9wdGlvbmFsIHRoZSBwcm9ncmVzcyBvZiB0aGUgYWN0dWFsIHN0ZXAgCisJICoKKwkgKiBAcmV0dXJuIHRoZSByZWNvbW1lbmRlZCBwcm9ncmVzcyB2YWx1ZQorCSAqLworCXB1YmxpYyBhYnN0cmFjdCBkb3VibGUgZ2V0UmVjb21tZW5kZWRQcm9ncmVzc1ZhbHVlKCk7CisKKwkvKioKKwkgKiBHZXRzIHRoZSByZWNvbW1lbmRlZCBwcm9ncmVzcyB0aXRsZS4KKwkgKgorCSAqIEBwYXJhbSB3aXRoUGVyY2VudCB0aGUgd2l0aCBwZXJjZW50CisJICogQHJldHVybiB0aGUgcmVjb21tZW5kZWQgcHJvZ3Jlc3MgdGl0bGUKKwkgKi8KKwlwdWJsaWMgYWJzdHJhY3QgU3RyaW5nIGdldFJlY29tbWVuZGVkUHJvZ3Jlc3NUaXRsZShib29sZWFuIHdpdGhQZXJjZW50KTsKKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvaW5pdGlhbGl6YXRpb24vSUluaXRpYWxpemF0aW9uUHJvdmlkZXIuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0lJbml0aWFsaXphdGlvblByb3ZpZGVyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2FiZWU5MgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0lJbml0aWFsaXphdGlvblByb3ZpZGVyLmphdmEKQEAgLTAsMCArMSwzMCBAQAorLyoqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgICAgICAgICAgIAorICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wICAgICAgIAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgICAgICAgICAgICAgICAgICAKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqIENvbnRyaWJ1dG9yczogICAKKyAqIENocmlzdG9waGUgTG9ldHogKExvZXR6IEdtYkgmQ28uS0cpIC0gaW5pdGlhbCBpbXBsZW1lbnRhdGlvbiAKKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLnVpLmluaXRpYWxpemF0aW9uOworCitwdWJsaWMgaW50ZXJmYWNlIElJbml0aWFsaXphdGlvblByb3ZpZGVyIHsKKworCWFic3RyYWN0IHB1YmxpYyBib29sZWFuIGhhc0luaXRpYWxpemF0aW9uVG9CZURvbmUoKTsKKworCXB1YmxpYyBhYnN0cmFjdCB2b2lkIGFkZEluaXRpYWxpemF0aW9uTGlzdGVuZXIoCisJCQlBYnN0cmFjdEluaXRpYWxpemF0aW9uTGlzdGVuZXIgbGlzdGVuZXIpOworCisJcHVibGljIGFic3RyYWN0IHZvaWQgcmVtb3ZlSW5pdGlhbGl6YXRpb25MaXN0ZW5lcigKKwkJCUlJbml0aWFsaXphdGlvbkxpc3RlbmVyIGxpc3RlbmVyKTsKKworCXB1YmxpYyBhYnN0cmFjdCB2b2lkIG5vdGlmeUluaXRpYWxpemF0aW9uU3RlcCgKKwkJCUlJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbiBub3RpZmljYXRpb24pOworCisJcHVibGljIGFic3RyYWN0IHZvaWQgbm90aWZ5SW5pdGlhbGl6YXRpb25Eb25lKCk7CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0luaXRpYWxpemF0aW9uRG9uZU5vdGlmaWNhdGlvbi5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC51aS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvdWkvaW5pdGlhbGl6YXRpb24vSW5pdGlhbGl6YXRpb25Eb25lTm90aWZpY2F0aW9uLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDFiNGU1MAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0luaXRpYWxpemF0aW9uRG9uZU5vdGlmaWNhdGlvbi5qYXZhCkBAIC0wLDAgKzEsMjYgQEAKKy8qKgorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzICAgICAgICAgICAKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgICAgICAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0ICAgICAgICAgICAgICAgICAgCisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgKiBDb250cmlidXRvcnM6ICAgCisgKiBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgaW1wbGVtZW50YXRpb24gCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC51aS5pbml0aWFsaXphdGlvbjsKKworLyoqCisgKiBUaGUgQ2xhc3MgSW5pdGlhbGl6YXRpb25Eb25lTm90aWZpY2F0aW9uLgorICovCitwdWJsaWMgZmluYWwgY2xhc3MgSW5pdGlhbGl6YXRpb25Eb25lTm90aWZpY2F0aW9uIGV4dGVuZHMgSW5pdGlhbGl6YXRpb25Ob3RpZmljYXRpb24geworCQorCS8qKgorCSAqIEluc3RhbnRpYXRlcyBhIG5ldyBpbml0aWFsaXphdGlvbiBkb25lIG5vdGlmaWNhdGlvbi4KKwkgKi8KKwlwdWJsaWMgSW5pdGlhbGl6YXRpb25Eb25lTm90aWZpY2F0aW9uKEFic3RyYWN0SW5pdGlhbGl6YXRpb25Qcm92aWRlciBpbml0aWFsaXphdGlvblByb3ZpZGVyKSB7CisJCXN1cGVyKGluaXRpYWxpemF0aW9uUHJvdmlkZXIpOworCX0KK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAudWkuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL3VpL2luaXRpYWxpemF0aW9uL0luaXRpYWxpemF0aW9uTm90aWZpY2F0aW9uLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9pbml0aWFsaXphdGlvbi9Jbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbi5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjk0ZDk5ZjEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC91aS9pbml0aWFsaXphdGlvbi9Jbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbi5qYXZhCkBAIC0wLDAgKzEsMTU1IEBACisvKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAgICAgICAgICAgCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgICAgICAgCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgICAgIAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorICogQ29udHJpYnV0b3JzOiAgIAorICogQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIGltcGxlbWVudGF0aW9uIAorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAudWkuaW5pdGlhbGl6YXRpb247CisKKy8vIFRPRE86IEF1dG8tZ2VuZXJhdGVkIEphdmFkb2MKKy8qKgorICogTm90aWZpY2F0aW9uIHdpdGggaW5mb3JtYXRpb24gYWJvdXQgdGhlIGFjdHVhbCBpbml0aWFsaXphdGlvbi4KKyAqLworcHVibGljIGNsYXNzIEluaXRpYWxpemF0aW9uTm90aWZpY2F0aW9uIGltcGxlbWVudHMgSUluaXRpYWxpemF0aW9uTm90aWZpY2F0aW9uIHsKKworCS8qKiBUaGUgcHJvdmlkZXIgdGl0bGUuICovCisJcHJpdmF0ZSBmaW5hbCBJSW5pdGlhbGl6YXRpb25Qcm92aWRlciBpbml0aWFsaXphdGlvblByb3ZpZGVyOworCisJLyoqIFRoZSBwcm92aWRlciB0aXRsZS4gKi8KKwlwcml2YXRlIGZpbmFsIFN0cmluZyBwcm92aWRlclRpdGxlOworCisJLyoqICBmbGFnIGlzIHRoZSB0b3RhbCBpbml0aWFsaXphdGlvbiBoYXMgYmVlbiBkb25lLiAqLworCXByaXZhdGUgZmluYWwgYm9vbGVhbiBkb25lOworCQorCS8qKiBUaGUgbnVtYmVyIG9mIHN0ZXBzIGRvbmUuICovCisJcHJpdmF0ZSBmaW5hbCBpbnQgc3RlcHNEb25lOworCQorCS8qKiBUaGUgc3RlcCB0aXRsZS4gKi8KKwlwcml2YXRlIGZpbmFsIFN0cmluZyBzdGVwVGl0bGU7CisJCisJLyoqIFRoZSB0b3RhbCBzdGVwcy4gKi8KKwlwcml2YXRlIGZpbmFsIGludCB0b3RhbFN0ZXBzOworCQorCS8qKiBUaGUgcHJvZ3Jlc3Mgb2Ygc3RlcC4gKi8KKwlwcml2YXRlIGZpbmFsIGRvdWJsZSBwcm9ncmVzc09mU3RlcDsKKworCS8qKgorCSAqIEluc3RhbnRpYXRlcyBhIG5ldyBpbml0aWFsaXphdGlvbiBub3RpZmljYXRpb24gZm9yIGEgZG9uZS4KKwkgKgorCSAqIEBwYXJhbSBwcm92aWRlclRpdGxlIHRoZSBwcm92aWRlciB0aXRsZQorCSAqIEBwYXJhbSB0b3RhbFN0ZXBzIHRoZSB0b3RhbCBzdGVwcworCSAqLworCXByb3RlY3RlZCBJbml0aWFsaXphdGlvbk5vdGlmaWNhdGlvbihBYnN0cmFjdEluaXRpYWxpemF0aW9uUHJvdmlkZXIgaW5pdGlhbGl6YXRpb25Qcm92aWRlcikgeworCQl0aGlzKGluaXRpYWxpemF0aW9uUHJvdmlkZXIsIG51bGwsIGluaXRpYWxpemF0aW9uUHJvdmlkZXIuZ2V0SW5pdGlhbGl6YXRpb25Ub3RhbFN0ZXBzKCksIDEuMCk7CisJfQorCQorCS8qKgorCSAqIEluc3RhbnRpYXRlcyBhIG5ldyBpbml0aWFsaXphdGlvbiBub3RpZmljYXRpb24uCisJICoKKwkgKiBAcGFyYW0gcHJvdmlkZXJUaXRsZSB0aGUgcHJvdmlkZXIgdGl0bGUKKwkgKiBAcGFyYW0gdG90YWxTdGVwcyB0aGUgdG90YWwgc3RlcHMKKwkgKiBAcGFyYW0gc3RlcFRpdGxlIHRoZSBzdGVwIHRpdGxlCisJICogQHBhcmFtIG51bWJlck9mU3RlcCB0aGUgbnVtYmVyIG9mIHN0ZXAKKwkgKi8KKwlwdWJsaWMgSW5pdGlhbGl6YXRpb25Ob3RpZmljYXRpb24oQWJzdHJhY3RJbml0aWFsaXphdGlvblByb3ZpZGVyIGluaXRpYWxpemF0aW9uUHJvdmlkZXIsIFN0cmluZyBzdGVwVGl0bGUsIGludCBzdGVwc0RvbmUpIHsKKwkJdGhpcyhpbml0aWFsaXphdGlvblByb3ZpZGVyLCBzdGVwVGl0bGUsIHN0ZXBzRG9uZSwgLTEuMCk7CisJfQorCQorCS8qKgorCSAqIEluc3RhbnRpYXRlcyBhIG5ldyBpbml0aWFsaXphdGlvbiBub3RpZmljYXRpb24uCisJICoKKwkgKiBAcGFyYW0gcHJvdmlkZXJUaXRsZSAJdGhlIHByb3ZpZGVyIHRpdGxlCisJICogQHBhcmFtIHRvdGFsU3RlcHMgCQl0aGUgY291bnQgb2YgdG90YWwgc3RlcHMKKwkgKiBAcGFyYW0gc3RlcFRpdGxlIAkJdGhlIGFjdHVhbCBzdGVwcyB0aXRsZQorCSAqIEBwYXJhbSBudW1iZXJPZlN0ZXAgCQl0aGUgbnVtYmVyIG9mIGFjdHVhbCBzdGVwCisJICogQHBhcmFtIHByb2dyZXNzT2ZTdGVwIAl0aGUgcHJvZ3Jlc3Mgb2YgYWN0dWFsIHN0ZXAKKwkgKi8KKwlwdWJsaWMgSW5pdGlhbGl6YXRpb25Ob3RpZmljYXRpb24oQWJzdHJhY3RJbml0aWFsaXphdGlvblByb3ZpZGVyIGluaXRpYWxpemF0aW9uUHJvdmlkZXIsIFN0cmluZyBzdGVwVGl0bGUsIGludCBzdGVwc0RvbmUsIGRvdWJsZSBwcm9ncmVzc09mU3RlcCkgeworCQl0aGlzLmluaXRpYWxpemF0aW9uUHJvdmlkZXIgPSBpbml0aWFsaXphdGlvblByb3ZpZGVyOworCQl0aGlzLnByb3ZpZGVyVGl0bGUgPSBpbml0aWFsaXphdGlvblByb3ZpZGVyLmdldEluaXRpYWxpemF0aW9uUHJvdmlkZXJUaXRsZSgpLnRyaW0oKTsKKwkJdGhpcy50b3RhbFN0ZXBzID0gTWF0aC5tYXgoMSwgaW5pdGlhbGl6YXRpb25Qcm92aWRlci5nZXRJbml0aWFsaXphdGlvblRvdGFsU3RlcHMoKSk7CisJCWlmCShzdGVwVGl0bGUgPT0gbnVsbCB8fCBzdGVwVGl0bGUudHJpbSgpLmlzRW1wdHkoKSkgeworCQkJdGhpcy5zdGVwVGl0bGUgPSBudWxsOworCQl9CisJCWVsc2UgeworCQkJdGhpcy5zdGVwVGl0bGUgPSBzdGVwVGl0bGUudHJpbSgpOworCQl9CisJCWlmCShzdGVwc0RvbmUgPCAxKSB7CisJCQl0aGlzLnN0ZXBzRG9uZSA9IDE7CisJCX0KKwkJZWxzZSBpZiAoc3RlcHNEb25lID4gdG90YWxTdGVwcykgeworCQkJdGhpcy5zdGVwc0RvbmUgPSB0b3RhbFN0ZXBzOworCQl9CisJCWVsc2UgeworCQkJdGhpcy5zdGVwc0RvbmUgPSBzdGVwc0RvbmU7CisJCX0KKwkJLy8gLS0tIGlmIGEgbmVnYXRpdmUgdmFsdWUgaXMgc2V0LCBubyBwcm9ncmVzcyBvZiB0aGUgYWN0dWFsIHN0ZXAgaXMgYXZhaWxhYmxlCisJCWlmCShwcm9ncmVzc09mU3RlcCA8IDAuMCkgeworCQkJdGhpcy5wcm9ncmVzc09mU3RlcCA9IC0xLjA7CisJCX0KKwkJLy8gLS0tIG90aGVyd2lzZSB0aGUgCisJCWVsc2UgeworCQkJdGhpcy5wcm9ncmVzc09mU3RlcCA9IE1hdGgubWluKDEuMCwgcHJvZ3Jlc3NPZlN0ZXApOworCQl9CisJCXRoaXMuZG9uZSA9ICgodGhpcy5zdGVwc0RvbmUgPj0gdGhpcy50b3RhbFN0ZXBzKSAmJiAocHJvZ3Jlc3NPZlN0ZXAgPj0gMS4wKSk7CisJfQorCQorCXB1YmxpYyBib29sZWFuIGlzRG9uZSgpIHsKKwkJcmV0dXJuIGRvbmU7CisJfQorCQorCS8qIChub24tSmF2YWRvYykKKwkgKiBAc2VlIG9yZy5lY2xpcHNlLm9zYnAudWkuaW5pdGlhbGl6YXRpb24uSUluaXRpYWxpemF0aW9uTm90aWZpY2F0aW9uI2dldEluaXRpYWxpemF0aW9uUHJvdmlkZXIoKQorCSAqLworCUBPdmVycmlkZQorCXB1YmxpYyBJSW5pdGlhbGl6YXRpb25Qcm92aWRlciBnZXRJbml0aWFsaXphdGlvblByb3ZpZGVyKCkgeworCQlyZXR1cm4gaW5pdGlhbGl6YXRpb25Qcm92aWRlcjsKKwl9CisJCisJLyogKG5vbi1KYXZhZG9jKQorCSAqIEBzZWUgb3JnLmVjbGlwc2Uub3NicC51aS5pbml0aWFsaXphdGlvbi5JSW5pdGlhbGl6YXRpb25Ob3RpZmljYXRpb24jZ2V0UmVjb21tZW5kZWRQcm9ncmVzc1ZhbHVlKCkKKwkgKi8KKwlAT3ZlcnJpZGUKKwlwdWJsaWMgZG91YmxlIGdldFJlY29tbWVuZGVkUHJvZ3Jlc3NWYWx1ZSgpIHsKKwkJLy8gLS0tIGNhbGN1bGF0ZSB0aGUgcHJvZ3Jlc3MgdmFsdWUgZGVwZW5kaW5nIG9uIHN0ZXBzIGxldmVsIC0tLQorCQlkb3VibGUgcHJvZ3Jlc3NWYWx1ZSA9ICgoZG91YmxlKXN0ZXBzRG9uZSAtIDEpIC8gKChkb3VibGUpdG90YWxTdGVwcyk7CisJCS8vIC0tLSBpZiBhdmFpbGFibGUgYWRkIHRoZSBzdGVwIHNwZWNpZmljIHByb2dyZXNzIHZhbHVlIC0tLQorCQlpZgkocHJvZ3Jlc3NPZlN0ZXAgPiAwLjApIHsKKwkJCXByb2dyZXNzVmFsdWUgKz0gcHJvZ3Jlc3NPZlN0ZXAgLyAoKGRvdWJsZSl0b3RhbFN0ZXBzKTsKKwkJfQorCQkvLyAtLS0gZW5zdXJlIGEgcHJvZ3Jlc3MgdmFsdWUgYmV0d2VlbiAwLjAgYW5kIDEuMAorCQlyZXR1cm4gTWF0aC5taW4oMS4wLCBNYXRoLm1heCgwLjAsIHByb2dyZXNzVmFsdWUpKTsKKwl9CisJCisJLyogKG5vbi1KYXZhZG9jKQorCSAqIEBzZWUgb3JnLmVjbGlwc2Uub3NicC51aS5pbml0aWFsaXphdGlvbi5JSW5pdGlhbGl6YXRpb25Ob3RpZmljYXRpb24jZ2V0UmVjb21tZW5kZWRQcm9ncmVzc1RpdGxlKGJvb2xlYW4pCisJICovCisJQE92ZXJyaWRlCisJcHVibGljIFN0cmluZyBnZXRSZWNvbW1lbmRlZFByb2dyZXNzVGl0bGUoYm9vbGVhbiB3aXRoUGVyY2VudCkgeworCQlTdHJpbmcgcHJvZ3Jlc3NUaXRsZSA9IHByb3ZpZGVyVGl0bGUrIiAoIitzdGVwc0RvbmUrIi8iK3RvdGFsU3RlcHMrIikiOworCQlpZgkoZG9uZSkgeworCQkJcHJvZ3Jlc3NUaXRsZSArPSAiIGRvbmUiOworCQl9CisJCWVsc2UgaWYJKHN0ZXBUaXRsZSAhPSBudWxsKSB7CisJCQlwcm9ncmVzc1RpdGxlICs9ICIgIitzdGVwVGl0bGU7CisJCX0KKwkJaWYJKHdpdGhQZXJjZW50KSB7CisJCQlkb3VibGUgcHJvZ3Jlc3NWYWx1ZSA9IGdldFJlY29tbWVuZGVkUHJvZ3Jlc3NWYWx1ZSgpOworCQkJaW50IHBlcmNlbnQgPSAoaW50KShwcm9ncmVzc1ZhbHVlICogMTAwLjApOworCQkJaWYJKChwZXJjZW50ID09IDApICYmIChwcm9ncmVzc1ZhbHVlID4gMC4wKSkgeworCQkJCXBlcmNlbnQgPSAxOworCQkJfQorCQkJaWYJKChwZXJjZW50ID09IDEwMCkgJiYgKHByb2dyZXNzVmFsdWUgPCAxLjApKSB7CisJCQkJcGVyY2VudCA9IDk5OworCQkJfQorCQkJcHJvZ3Jlc3NUaXRsZSArPSAiIC0gIitwZXJjZW50KyIlIjsKKwkJfQorCQlyZXR1cm4gcHJvZ3Jlc3NUaXRsZTsKKwl9Cit9CmRpZmYgLS1naXQgYS9wb20ueG1sIGIvcG9tLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wM2Y3YjA5Ci0tLSAvZGV2L251bGwKKysrIGIvcG9tLnhtbApAQCAtMCwwICsxLDk1IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzwhLS0jIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpLiAtLT4KKzwhLS0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgLS0+Cis8IS0tIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgLS0+Cis8IS0tIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAtLT4KKzwhLS0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIC0tPgorPCEtLSMgLS0+Cis8IS0tIyBDb250cmlidXRvcnM6IC0tPgorPCEtLSMgQ2hyaXN0b3BoZSBMb2V0eiAgKExvZXR6IEdtYkgmQ28uS0cpIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbiBBUEkgYW5kIGltcGxlbWVudGF0aW9uIC0tPgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzxwcm9qZWN0IHhtbG5zPSJodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9QT00vNC4wLjAiIHhtbG5zOnhzaT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEtaW5zdGFuY2UiIHhzaTpzY2hlbWFMb2NhdGlvbj0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIGh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL3hzZC9tYXZlbi00LjAuMC54c2QiPgorICAgIDxtb2RlbFZlcnNpb24+NC4wLjA8L21vZGVsVmVyc2lvbj4KKworICAgIDxwYXJlbnQ+CisgICAgICAgIDxncm91cElkPm9yZy5lY2xpcHNlLm9zYnAucmVsZW5nLm1hdmVuPC9ncm91cElkPgorICAgICAgICA8YXJ0aWZhY3RJZD5vcmcuZWNsaXBzZS5vc2JwLnJlbGVuZy5tYXZlbi5wYXJlbnQudHljaG88L2FydGlmYWN0SWQ+CisgICAgICAgIDx2ZXJzaW9uPjAuOS4wLVNOQVBTSE9UPC92ZXJzaW9uPgorICAgICAgICA8cmVsYXRpdmVQYXRoLz4KKyAgICA8L3BhcmVudD4KKworICAgIDxncm91cElkPm9yZy5lY2xpcHNlLm9zYnAudWkuYXBpPC9ncm91cElkPgorICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAudWkuYXBpLmFnZ3JlZ2F0b3I8L2FydGlmYWN0SWQ+CisgICAgPHZlcnNpb24+MC45LjAtU05BUFNIT1Q8L3ZlcnNpb24+CisgICAgPHBhY2thZ2luZz5wb208L3BhY2thZ2luZz4KKworICAgIDx1cmw+JHtvc2JwLnNpdGUucmVwb3NpdG9yeS51cmx9PC91cmw+CisgICAgPHNjbT4KKyAgICAgICAgPHVybD4ke29zYnAuc2NtLnVybH08L3VybD4KKyAgICAgICAgPGNvbm5lY3Rpb24+JHtvc2JwLnNjbS5jb25uZWN0aW9ufTwvY29ubmVjdGlvbj4KKyAgICAgICAgPGRldmVsb3BlckNvbm5lY3Rpb24+JHtvc2JwLnNjbS5jb25uZWN0aW9uLmRldn08L2RldmVsb3BlckNvbm5lY3Rpb24+CisgICAgICAgIDx0YWc+SEVBRDwvdGFnPgorICAgIDwvc2NtPgorICAgIDxkaXN0cmlidXRpb25NYW5hZ2VtZW50PgorICAgICAgICA8c2l0ZT4KKyAgICAgICAgICAgIDxpZD5naC1wYWdlczwvaWQ+CisgICAgICAgICAgICA8bmFtZT5PU0JQIEdpdEh1YiBQYWdlczwvbmFtZT4KKyAgICAgICAgICAgIDx1cmw+JHtkaXN0cmlidXRpb24uc2l0ZS51cmx9PC91cmw+CisgICAgICAgIDwvc2l0ZT4KKyAgICA8L2Rpc3RyaWJ1dGlvbk1hbmFnZW1lbnQ+CisKKwk8cHJvcGVydGllcz4KKwkJPG9zYnAuZ2l0cmVwby5uYW1lPiR7cHJvamVjdC5ncm91cElkfTwvb3NicC5naXRyZXBvLm5hbWU+CisJPC9wcm9wZXJ0aWVzPgorCisgICAgPG1vZHVsZXM+CisgICAgICAgIDxtb2R1bGU+b3JnLmVjbGlwc2Uub3NicC51aS5hcGk8L21vZHVsZT4KKyAgICAgICAgPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLnVpLmFwaS5mZWF0dXJlPC9tb2R1bGU+CisgICAgPC9tb2R1bGVzPgorCisgICAgPGJ1aWxkPgorICAgICAgICA8cGx1Z2luTWFuYWdlbWVudD4KKyAgICAgICAgICAgIDxwbHVnaW5zPgorICAgICAgICAgICAgICAgIDxwbHVnaW4+CisgICAgICAgICAgICAgICAgICAgIDxncm91cElkPm9yZy5hcGFjaGUubWF2ZW4ucGx1Z2luczwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICAgICAgPGFydGlmYWN0SWQ+bWF2ZW4tamF2YWRvYy1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgICAgIDxjb25maWd1cmF0aW9uPgorICAgICAgICAgICAgICAgICAgICAgICAgPHNraXA+dHJ1ZTwvc2tpcD4KKyAgICAgICAgICAgICAgICAgICAgPC9jb25maWd1cmF0aW9uPgorICAgICAgICAgICAgICAgIDwvcGx1Z2luPgorICAgICAgICAgICAgICAgIDxwbHVnaW4+CisgICAgICAgICAgICAgICAgICAgIDxncm91cElkPm9yZy5lY2xpcHNlLnR5Y2hvPC9ncm91cElkPgorICAgICAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD50YXJnZXQtcGxhdGZvcm0tY29uZmlndXJhdGlvbjwvYXJ0aWZhY3RJZD4KKyAgICAgICAgICAgICAgICAgICAgPHZlcnNpb24+JHt0eWNoby12ZXJzaW9ufTwvdmVyc2lvbj4KKyAgICAgICAgICAgICAgICAgICAgPGNvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICAgICAgICAgICAgICA8cmVzb2x2ZXI+cDI8L3Jlc29sdmVyPgorICAgICAgICAgICAgICAgICAgICAgICAgPHBvbURlcGVuZGVuY2llcz5jb25zaWRlcjwvcG9tRGVwZW5kZW5jaWVzPgorICAgICAgICAgICAgICAgICAgICAgICAgPGVudmlyb25tZW50cz4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZW52aXJvbm1lbnQ+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxvcz53aW4zMjwvb3M+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx3cz53aW4zMjwvd3M+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhcmNoPng4Nl82NDwvYXJjaD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Vudmlyb25tZW50PgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbnZpcm9ubWVudD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPG9zPmxpbnV4PC9vcz4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHdzPmd0azwvd3M+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhcmNoPng4NjwvYXJjaD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Vudmlyb25tZW50PgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbnZpcm9ubWVudD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPG9zPmxpbnV4PC9vcz4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHdzPmd0azwvd3M+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhcmNoPng4Nl82NDwvYXJjaD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Vudmlyb25tZW50PgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbnZpcm9ubWVudD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPG9zPm1hY29zeDwvb3M+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDx3cz5jb2NvYTwvd3M+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxhcmNoPng4Nl82NDwvYXJjaD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Vudmlyb25tZW50PgorICAgICAgICAgICAgICAgICAgICAgICAgPC9lbnZpcm9ubWVudHM+CisgICAgICAgICAgICAgICAgICAgIDwvY29uZmlndXJhdGlvbj4KKyAgICAgICAgICAgICAgICA8L3BsdWdpbj4KKyAgICAgICAgICAgIDwvcGx1Z2lucz4KKyAgICAgICAgPC9wbHVnaW5NYW5hZ2VtZW50PgorICAgIDwvYnVpbGQ+Cis8L3Byb2plY3Q+Cg==